Publicação
Thread-Aware Data Race Detection in Java Classes
| Resumo: | The rise of concurrent programming revolutionized the world of computing by improving program efficiency and performance. However, it introduced the state explosion problem and troublesome data races. Since then, computer scientists have focused on continuously abstracting programs, devising techniques and tools to help developers manage the increasingly complex task of synchronizing shared data accesses. State-of-the-art data race detectors like RacerD and SWORD are capable of capturing concurrency bugs in multithreaded programs, but lack context reasoning, leading to false positives, and rely on the programmer to explicitly adjust their programs based on the output. Even if an object is never shared beyond the execution of a thread, static analysis tools are conservative and may assume all accesses can run in parallel in the absence of synchronization, reporting data races that cannot really occur. This dissertation proposes a solution involving the static analysis of program classes, without concurrency control, for the detection of memory accesses that lead to data races. This is based on conflicting accesses involving class instances and their shared mutable states to indicate the need to provide atomic accesses by annotating class fields. It is meant to be utilized as input for the compilation of the AtomiS framework, which automatically generates concurrency control based on annotated code, thereby removing the need for programmers to manually address concurrency issues. The solution can distinguish the instances that each thread accesses and associate them with their execution contexts to output more precise reports than RacerD and SWORD. Our approach identifies the instance fields that should be accessed atomically as a consequence of being the target of data races between distinct threads, but still requires inter-method access analysis to yield more precise and complete results and reduce false negatives, and adequate annotation inference. In the future, once these improvements are appropriately implemented and the current work is refined by modeling method calls, to reflect changes to caller objects and parameters, programmers might not need to approach their multithreaded programs to define synchronization for shared accesses. |
|---|---|
| Autores principais: | Correia, André Alexandre Silva |
| Assunto: | static analysis data race thread-awareness concurrency control |
| Ano: | 2025 |
| País: | Portugal |
| Tipo de documento: | dissertação de mestrado |
| Tipo de acesso: | acesso aberto |
| Instituição associada: | Universidade Nova de Lisboa |
| Idioma: | inglês |
| Origem: | Repositório Institucional da UNL |
| _version_ | 1868415536513155072 |
|---|---|
| author | Correia, André Alexandre Silva |
| author_facet | Correia, André Alexandre Silva |
| author_role | author |
| contributor_name_str_mv | Paulino, Hervé Ravara, António RUN |
| country_str | PT |
| creators_json_txt | [{\"Person.name\":\"Correia, André Alexandre Silva\"}] |
| datacite.contributors.contributor.contributorName.fl_str_mv | Paulino, Hervé Ravara, António RUN |
| datacite.creators.creator.creatorName.fl_str_mv | Correia, André Alexandre Silva |
| datacite.date.Accepted.fl_str_mv | 2025-12-09T00:00:00Z |
| datacite.date.available.fl_str_mv | 2026-05-04T10:35:19Z |
| datacite.date.embargoed.fl_str_mv | 2026-05-04T10:35:19Z |
| datacite.rights.fl_str_mv | http://purl.org/coar/access_right/c_abf2 |
| datacite.subjects.subject.fl_str_mv | static analysis data race thread-awareness concurrency control |
| datacite.titles.title.fl_str_mv | Thread-Aware Data Race Detection in Java Classes |
| dc.contributor.none.fl_str_mv | Paulino, Hervé Ravara, António RUN |
| dc.creator.none.fl_str_mv | Correia, André Alexandre Silva |
| dc.date.Accepted.fl_str_mv | 2025-12-09T00:00:00Z |
| dc.date.available.fl_str_mv | 2026-05-04T10:35:19Z |
| dc.date.embargoed.fl_str_mv | 2026-05-04T10:35:19Z |
| dc.description.none.fl_str_mv | Avanços na programação concorrente revolucionaram a eficiência e desempenho de programas. No entanto, também introduziram o problema da explosão de estados e data races. Desde então, os cientistas da computação têm-se focado na abstração de programas, desenvolvendo novas técnicas e ferramentas para ajudar os programadores a gerir a sincronização de acessos a dados partilhados. Detetores de data race do estado-da-arte como RacerD e SWORD são capazes de captar bugs em programas concorrentes, mas não contabilizam o contexto de execução e devolvem falsos positivos, e os programadores têm que ajustar os seus programas com base nesses resultados. Mesmo que um objeto nunca seja partilhado por várias threads, a análise estática é conservativa e pode assumir que os acessos são executados em paralelo fora de sincronização, resultando em data races que podem não ocorrer. Esta dissertação propõe uma solução de análise estática das classes de um programa, sem controle de concorrência, para a deteção de acessos que levam a potenciais data races. Isto é baseado em acessos conflituosos a instâncias de classe e os seus estados mutáveis partilhados para indicar a necessidade de anotar os campos das classes para acessos atómi- cos. Os resultados são prentendidos como valor de entrada à compilação da framework do AtomiS, que trata de gerar controle de concorrência automaticamente baseado em código anotado, eliminando a necessidade de abordar problemas de concorrência manualmente. A solução distingue as instâncias a que cada thread acede e associa-as com os contextos de execução das mesmas para obter resultados mais precisos que o RacerD e o SWORD. Esta abordagem identifica campos de instâncias que devem ser acedidos atomicamente por serem alvos de data race entre threads distintas, mas requer análise de acessos inter-método para obter resultados mais precisos e completos e reduzir falsos negativos, e inferência das anotações adequadas. No futuro, quando estes melhoramentos forem implementados e o trabalhado atual modelar chamadas de métodos, para refletir mudanças sobre objetos de chamada e parâmetros, os programadores podem não precisar de abordar os seus programas concorrentes para definir sincronização de acessos partilhados. |
| dc.format.none.fl_str_mv | application/pdf |
| dc.identifier.none.fl_str_mv | http://hdl.handle.net/10362/202774 |
| dc.language.none.fl_str_mv | eng |
| dc.rights.cclincense.fl_str_mv | http://creativecommons.org/licenses/by/4.0/ |
| dc.rights.none.fl_str_mv | http://purl.org/coar/access_right/c_abf2 |
| dc.subject.none.fl_str_mv | static analysis data race thread-awareness concurrency control |
| dc.title.fl_str_mv | Thread-Aware Data Race Detection in Java Classes |
| dc.type.none.fl_str_mv | http://purl.org/coar/resource_type/c_bdcc |
| description | The rise of concurrent programming revolutionized the world of computing by improving program efficiency and performance. However, it introduced the state explosion problem and troublesome data races. Since then, computer scientists have focused on continuously abstracting programs, devising techniques and tools to help developers manage the increasingly complex task of synchronizing shared data accesses. State-of-the-art data race detectors like RacerD and SWORD are capable of capturing concurrency bugs in multithreaded programs, but lack context reasoning, leading to false positives, and rely on the programmer to explicitly adjust their programs based on the output. Even if an object is never shared beyond the execution of a thread, static analysis tools are conservative and may assume all accesses can run in parallel in the absence of synchronization, reporting data races that cannot really occur. This dissertation proposes a solution involving the static analysis of program classes, without concurrency control, for the detection of memory accesses that lead to data races. This is based on conflicting accesses involving class instances and their shared mutable states to indicate the need to provide atomic accesses by annotating class fields. It is meant to be utilized as input for the compilation of the AtomiS framework, which automatically generates concurrency control based on annotated code, thereby removing the need for programmers to manually address concurrency issues. The solution can distinguish the instances that each thread accesses and associate them with their execution contexts to output more precise reports than RacerD and SWORD. Our approach identifies the instance fields that should be accessed atomically as a consequence of being the target of data races between distinct threads, but still requires inter-method access analysis to yield more precise and complete results and reduce false negatives, and adequate annotation inference. In the future, once these improvements are appropriately implemented and the current work is refined by modeling method calls, to reflect changes to caller objects and parameters, programmers might not need to approach their multithreaded programs to define synchronization for shared accesses. |
| dirty | 0 |
| eu_rights_str_mv | openAccess |
| format | masterThesis |
| fulltext.url.fl_str_mv | https://run.unl.pt/bitstreams/789b2a85-4f46-4526-a38d-473da68ed128/download |
| id | run_55ce6eccecf08d8bc7c4634bbcd89b97 |
| identifier.url.fl_str_mv | http://hdl.handle.net/10362/202774 |
| instacron_str | unl |
| institution | Universidade Nova de Lisboa |
| instname_str | Universidade Nova de Lisboa |
| language | eng |
| network_acronym_str | run |
| network_name_str | Repositório Institucional da UNL |
| oai_identifier_str | oai:run.unl.pt:10362/202774 |
| organization_str_mv | urn:organizationAcronym:unl |
| person_str_mv | Correia, André Alexandre Silva |
| publishDate | 2025 |
| reponame_str | Repositório Institucional da UNL |
| repository_id_str | urn:repositoryAcronym:run |
| service_str_mv | urn:repositoryAcronym:run |
| spelling | engengThe rise of concurrent programming revolutionized the world of computing by improving program efficiency and performance. However, it introduced the state explosion problem and troublesome data races. Since then, computer scientists have focused on continuously abstracting programs, devising techniques and tools to help developers manage the increasingly complex task of synchronizing shared data accesses. State-of-the-art data race detectors like RacerD and SWORD are capable of capturing concurrency bugs in multithreaded programs, but lack context reasoning, leading to false positives, and rely on the programmer to explicitly adjust their programs based on the output. Even if an object is never shared beyond the execution of a thread, static analysis tools are conservative and may assume all accesses can run in parallel in the absence of synchronization, reporting data races that cannot really occur. This dissertation proposes a solution involving the static analysis of program classes, without concurrency control, for the detection of memory accesses that lead to data races. This is based on conflicting accesses involving class instances and their shared mutable states to indicate the need to provide atomic accesses by annotating class fields. It is meant to be utilized as input for the compilation of the AtomiS framework, which automatically generates concurrency control based on annotated code, thereby removing the need for programmers to manually address concurrency issues. The solution can distinguish the instances that each thread accesses and associate them with their execution contexts to output more precise reports than RacerD and SWORD. Our approach identifies the instance fields that should be accessed atomically as a consequence of being the target of data races between distinct threads, but still requires inter-method access analysis to yield more precise and complete results and reduce false negatives, and adequate annotation inference. In the future, once these improvements are appropriately implemented and the current work is refined by modeling method calls, to reflect changes to caller objects and parameters, programmers might not need to approach their multithreaded programs to define synchronization for shared accesses.porAvanços na programação concorrente revolucionaram a eficiência e desempenho de programas. No entanto, também introduziram o problema da explosão de estados e data races. Desde então, os cientistas da computação têm-se focado na abstração de programas, desenvolvendo novas técnicas e ferramentas para ajudar os programadores a gerir a sincronização de acessos a dados partilhados. Detetores de data race do estado-da-arte como RacerD e SWORD são capazes de captar bugs em programas concorrentes, mas não contabilizam o contexto de execução e devolvem falsos positivos, e os programadores têm que ajustar os seus programas com base nesses resultados. Mesmo que um objeto nunca seja partilhado por várias threads, a análise estática é conservativa e pode assumir que os acessos são executados em paralelo fora de sincronização, resultando em data races que podem não ocorrer. Esta dissertação propõe uma solução de análise estática das classes de um programa, sem controle de concorrência, para a deteção de acessos que levam a potenciais data races. Isto é baseado em acessos conflituosos a instâncias de classe e os seus estados mutáveis partilhados para indicar a necessidade de anotar os campos das classes para acessos atómi- cos. Os resultados são prentendidos como valor de entrada à compilação da framework do AtomiS, que trata de gerar controle de concorrência automaticamente baseado em código anotado, eliminando a necessidade de abordar problemas de concorrência manualmente. A solução distingue as instâncias a que cada thread acede e associa-as com os contextos de execução das mesmas para obter resultados mais precisos que o RacerD e o SWORD. Esta abordagem identifica campos de instâncias que devem ser acedidos atomicamente por serem alvos de data race entre threads distintas, mas requer análise de acessos inter-método para obter resultados mais precisos e completos e reduzir falsos negativos, e inferência das anotações adequadas. No futuro, quando estes melhoramentos forem implementados e o trabalhado atual modelar chamadas de métodos, para refletir mudanças sobre objetos de chamada e parâmetros, os programadores podem não precisar de abordar os seus programas concorrentes para definir sincronização de acessos partilhados.application/pdfengThread-Aware Data Race Detection in Java ClassesCorreia, André Alexandre SilvaPaulino, HervéRavara, AntónioHostingInstitutionOrganizationalRUNe-mailmailto:run@unl.ptrun@unl.pt2026-05-04T10:35:19Z2025-12-092025-12-09T00:00:00ZHandlehttp://hdl.handle.net/10362/202774http://purl.org/coar/access_right/c_abf2open accessstatic analysisdata racethread-awarenessconcurrency control1297423 bytesliteraturehttp://purl.org/coar/resource_type/c_bdccmaster thesis2025-12-09http://creativecommons.org/licenses/by/4.0/http://purl.org/coar/access_right/c_abf2application/pdffulltexthttps://run.unl.pt/bitstreams/789b2a85-4f46-4526-a38d-473da68ed128/download |
| spellingShingle | Thread-Aware Data Race Detection in Java Classes Correia, André Alexandre Silva static analysis data race thread-awareness concurrency control |
| status | SINGLETON |
| subject.fl_str_mv | static analysis data race thread-awareness concurrency control |
| title | Thread-Aware Data Race Detection in Java Classes |
| title_full | Thread-Aware Data Race Detection in Java Classes |
| title_fullStr | Thread-Aware Data Race Detection in Java Classes |
| title_full_unstemmed | Thread-Aware Data Race Detection in Java Classes |
| title_short | Thread-Aware Data Race Detection in Java Classes |
| title_sort | Thread-Aware Data Race Detection in Java Classes |
| topic | static analysis data race thread-awareness concurrency control |
| topic_facet | static analysis data race thread-awareness concurrency control |
| url | http://hdl.handle.net/10362/202774 |
| visible | 1 |