关于writer中锁的问题

synchronized(this),就是说锁住了this这个对象,mapToRead不是这个对象的一个变量吗?如果这个变量不被锁?那么被锁住的是什么?

2.2 Monitor = 锁
本文中会经常出现“monitor”和“锁”这两个词。本文中，这两个词的含义完全一样，可以互换。
monitor（锁）是Java虚拟机内部维护的一个结构，包含一些计数字段和一些队列（与操作系统的线程实现原理类似）。计数字段纪录队列里面线程的个数。
每个Java对象（Object）的reference（可以理解为对象的32-bit内存地址），都对应一个monitor结构。所以，任何reference类型的变量都可以提供monitor（锁），具有同步对象的资格。

8.13 Locks and Synchronization

There is a lock associated with every object. The Java programming language does not provide a way to perform separate lock and unlock operations; instead, they are implicitly performed by high-level constructs that always arrange to pair such operations correctly. (The Java virtual machine, however, provides separate monitorenter and monitorexit instructions that implement the lock and unlock operations.)

The synchronized statement computes a reference to an object; it then attempts to perform a lock operation on that object and does not proceed further until the lock operation has successfully completed. (A lock operation may be delayed because the rules about locks can prevent the main memory from participating until some other thread is ready to perform one or more unlock operations.) After the lock operation has been performed, the body of the synchronized statement is executed. Normally, a compiler for the Java programming language ensures that the lock operation implemented by a monitorenter instruction executed prior to the execution of the body of the synchronized statement is matched by an unlock operation implemented by a monitorexit instruction whenever the synchronized statement completes, whether completion is normal or abrupt.

A synchronized method automatically performs a lock operation when it is invoked; its body is not executed until the lock operation has successfully completed. If the method is an instance method, it locks the lock associated with the instance for which it was invoked (that is, the object that will be known as this during execution of the method's body). If the method is static, it locks the lock associated with the Class object that represents the class in which the method is defined. If execution of the method's body is ever completed, either normally or abruptly, an unlock operation is automatically performed on that same lock.

The monitorenter and monitorexit instructions exist to support synchronized statements. For example:


void onlyMe(Foo f) {
synchronized(f) {
doSomething();
}
}

is compiled to

Method void onlyMe(Foo)
0 aload_1 // Push f
1 astore_2 // Store it in local variable 2
2 aload_2 // Push local variable 2 (f)
3 monitorenter // Enter the monitor associated with f
4 aload_0 // Holding the monitor, pass this and...
5 invokevirtual #5 // ...call Example.doSomething()V
8 aload_2 // Push local variable 2 (f)
9 monitorexit // Exit the monitor associated with f
10 return // Return normally
11 aload_2 // In case of any throw, end up here
12 monitorexit // Be sure to exit monitor...
13 athrow // ...then rethrow the value to the invoker
Exception table:
From To Target Type
4 8 11 any