Object-oriented programming encourages extensive use of fields in objects. Most object-oriented programs are also concurrent, due to a finalizer or user interface thread. The combination of concurrency and frequent use of fields presents an optimization challenge: it is difficult for an optimizer to establish invariants between fields at different points in the program and recognize redundancy introduced by synchronization primitives. In this paper, we describe techniques to optimize code for field access in concurrent object-oriented programs. We leverage the fact that for correctness, programmers must use some form of concurrency control. We adapt several techniques for analyzing the synchronization properties of fields, including identifying fields associated with objects that are always locked before their use and identifying fields that are accessed from only one thread, to locate optimization opportunities that remain sound, even for concurrent programs. We extend existing optimizations, including redundant-load elimination, array-bounds check elimination, and null check elimination, to use these analyses. We show that extending these optimizations with a combination of analysis techniques is straightforward and relatively inexpensive, using analyses that already exist in mature object-oriented compilers. We also find that concurrency in our benchmarks does not substantially reduce the benefits of the original optimizations.