We present experimental results on how the granularity of locking provided by synchronization wrappers affects performance. The wrappers implement method-level synchronization whose exclusion behavior is specified using a declarative approach. Our experimental results with both Java and C# suggest that fine-grained exclusion control is worthwhile implementing, at least for heavily loaded objects, and that there appears to be no performance penalty in doing so. To overcome resistance to programming more complex and fragile synchronization code, we propose generating the code automatically, based on the exclusion specification. Essentially this only entails describing the read-write conflicts between method pairs in an object?s interface. The automatic code generation can either be done dynamically using existing reflection mechanisms, or statically by a compiler. In the latter case we envisage minor language extensions to allow programmers to specify both the exclusion requirements for a given object, and the exclusion control to be provided by a given object when it is constructed.