Concurrent Java programs are difficult to understand and implement correctly. This difficultly leads to code faults that are the source of many real-world reliability and security problems. Many factors contribute to concurrency faults in Java code; for example, programmers may not understand Java language semantics or, when using a Java library or framework, may not understand that their resulting program is concurrent. This thesis describes a dynamic analysis approach, implemented in a tool named FlashLight, that detects shared state and possible race conditions within a program. FlashLight illuminates the concurrency within a program for programmers that are wholly or partially \"in the dark\" about their software's concurrency. FlashLight also works in concert with the Fluid assurance tool to propose Greenhouse-style 8] lock policy models based upon a program's observed locking behavior. After review by a programmer to ensure reasonableness, these models can be verified by the Fluid assurance tool. Our combination of a dynamic tool with a program verification system focused on concurrency fault detection and repair is, to the best of our knowledge, novel and is the primary contribution of this research. We applied FlashLight to several concurrent Java programs, including a large (greater than 100kSLOC) commercial web application server. Our case study experiences in- duced us to improve FlashLight to (1) allow the programmer to specify interesting time quantums (e. g., this is the start up phase of my program) and (2) support the common Java programming idiom of not locking shared state during object construc- tion. Both improvements help to reduce false positives. FlashLight introduces an overhead of roughly 1.7 times the original execution time of the program. The most significant limitation of FlashLight is that it is not fully integrated into the Fluid assurance tool with respect to the user experience. | Flashlight by Scott C Hale, Paperback | Indigo Chapters