Java并发

最简单的东西，往往包含了最复杂的实现，因为需要为上层的存在提供一个稳定的基础，Object作为java中所有对象的基类，其存在的价值不言而喻，其中wait和notify方法的实现多线程协作提供了保证。

案例

1public class WaitTestDemo {
2
3	public static void main(String[] args) {
4		Message msg = new Message("process it");
5		Waiter waiter = new Waiter(msg);
6		new Thread(waiter,"waiterThread").start();
7
8		Waiter waiter1 = new Waiter(msg);
9		new Thread(waiter1, "waiter1Thread").start();
10		
11		Notifier notifier = new Notifier(msg);
12		new Thread(notifier, "notifierThread").start();
13 
14		System.out.println("All the threads are started");
15	}
16
17	public static class Message {
18		private String msg;
19		public Message(String str){
20			this.msg=str;
21		}
22		public String getMsg() {
23			return msg;
24		}
25		public void setMsg(String str) {
26			this.msg=str;
27		}
28	}
29
30	public static class Waiter implements Runnable{
31		private Message msg;
32		public Waiter(Message m){
33			this.msg=m;
34		}
35
36		@Override
37		public void run() {
38			String name = Thread.currentThread().getName();
39			synchronized (msg) {
40				try{
41					System.out.println(name+" waiting to get notified at time:"+System.currentTimeMillis());
42					msg.wait();
43				}catch(InterruptedException e){
44					e.printStackTrace();
45				}
46				System.out.println(name+" waiter thread got notified at time:"+System.currentTimeMillis());
47				//process the message now
48				System.out.println(name+" processed: "+msg.getMsg());
49			}
50		}
51	}
52
53	public static class Notifier implements Runnable {
54		private Message msg;
55
56		public Notifier(Message msg) {
57			this.msg = msg;
58		}
59
60		@Override
61		public void run() {
62			String name = Thread.currentThread().getName();
63			System.out.println(name+" started");
64			try {
65				Thread.sleep(1000);
66				synchronized (msg) {
67					msg.setMsg(name+" Notifier work done");
68					msg.notify();
69					msg.notify();
70					//msg.notifyAll();
71				}
72			} catch (InterruptedException e) {
73				e.printStackTrace();
74			}
75		}
76	}
77}
78

Output:

1All the threads are started
2waiterThread waiting to get notified at time:1572344152693
3waiter1Thread waiting to get notified at time:1572344152693
4notifierThread started
5waiterThread waiter thread got notified at time:1572344153705
6waiterThread processed: notifierThread Notifier work done
7waiter1Thread waiter thread got notified at time:1572344153706
8waiter1Thread processed: notifierThread Notifier work done

也可以使用notifyAll,输出为：

1All the threads are started
2waiterThread waiting to get notified at time:1572344222162
3waiter1Thread waiting to get notified at time:1572344222162
4notifierThread started
5waiter1Thread waiter thread got notified at time:1572344223175
6waiter1Thread processed: notifierThread Notifier work done
7waiterThread waiter thread got notified at time:1572344223177
8waiterThread processed: notifierThread Notifier work done

发现最后唤醒的顺序颠倒了

执行完notify方法，并不会立马唤醒等待线程，在notify方法后面加一段sleep代码就可以看到效果，如果线程执行完notify方法之后sleep 5s，在这段时间内，线程waiterThread1依旧持有monitor，线程waiterThread只能继续等待；

为什么要使用synchronized?

在Java中，synchronized有两种使用形式，同步方法和同步代码块。代码如下：

1public class SynchronizedTest {
2
3    public synchronized void doSth(){
4        System.out.println("Hello World");
5    }
6
7    public void doSth1(){
8        synchronized (SynchronizedTest.class){
9            System.out.println("Hello World");
10        }
11    }
12}

我们先来使用Javap来反编译以上代码，结果如下（部分无用信息过滤掉了）：

1public synchronized void doSth();
2    descriptor: ()V
3    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
4    Code:
5      stack=2, locals=1, args_size=1
6         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
7         3: ldc           #3                  // String Hello World
8         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
9         8: return
10
11  public void doSth1();
12    descriptor: ()V
13    flags: ACC_PUBLIC
14    Code:
15      stack=2, locals=3, args_size=1
16         0: ldc           #5                  // class com/hollis/SynchronizedTest
17         2: dup
18         3: astore_1
19         4: monitorenter
20         5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
21         8: ldc           #3                  // String Hello World
22        10: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23        13: aload_1
24        14: monitorexit
25        15: goto          23
26        18: astore_2
27        19: aload_1
28        20: monitorexit
29        21: aload_2
30        22: athrow
31        23: return

反编译后，我们可以看到Java编译器为我们生成的字节码。在对于doSth和doSth1的处理上稍有不同。也就是说。JVM对于同步方法和同步代码块的处理方式不同。

对于同步方法，JVM采用ACC_SYNCHRONIZED标记符来实现同步。对于同步代码块。JVM采用monitorenter、monitorexit两个指令来实现同步。

关于这部分内容，在JVM规范中也可以找到相关的描述。

同步方法

方法级的同步是隐式的。同步方法的常量池中会有一个ACC_SYNCHRONIZED标志。当某个线程要访问某个方法的时候，会检查是否有ACC_SYNCHRONIZED，如果有设置，则需要先获得监视器锁，然后开始执行方法，方法执行之后再释放监视器锁。这时如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。值得注意的是，如果在方法执行过程中，发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放。

同步代码块

同步代码块使用monitorenter和monitorexit两个指令实现。 The Java® Virtual Machine Specification 中有关于这两个指令的介绍：

大致内容如下：可以把执行monitorenter指令理解为加锁，执行monitorexit理解为释放锁。每个对象维护着一个记录着被锁次数的计数器。未被锁定的对象的该计数器为0，当一个线程获得锁（执行monitorenter）后，该计数器自增变为 1 ，当同一个线程再次获得该对象的锁的时候，计数器再次自增。当同一个线程释放锁（执行monitorexit指令）的时候，计数器再自减。当计数器为0的时候。锁将被释放，其他线程便可以获得锁。

归总

同步方法通过ACC_SYNCHRONIZED关键字隐式的对方法进行加锁。当线程要执行的方法被标注上ACC_SYNCHRONIZED时，需要先获得锁才能执行该方法。

同步代码块通过monitorenter和monitorexit执行来进行加锁。当线程执行到monitorenter的时候要先获得所锁，才能执行后面的方法。当线程执行到monitorexit的时候则要释放锁。

每个对象自身维护这一个被加锁次数的计数器，当计数器数字为0时表示可以被任意线程获得锁。当计数器不为0时，只有获得锁的线程才能再次获得锁。即可重入锁。

底层原理

对象头和内置锁(ObjectMonitor)

每个对象分为三块区域:对象头、实例数据和对齐填充。

对象头包含两部分，第一部分是Mark Word，用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等，这一部分占一个字节。第二部分是Klass Pointer（类型指针），是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，这部分也占一个字节。(如果对象是数组类型的，则需要3个字节来存储对象头，因为还需要一个字节存储数组的长度)
实例数据存放的是类属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。
填充数据是因为虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐。

级锁定、重量级锁定、GC标记、可偏向)下对象的存储内容如下表所示。

Synchronized通常被称为重量级锁，但是1.6之后对其进行优化，新增了轻量级锁和偏向锁，这里重点说下重量级锁，随后对Synchronized的优化简单介绍下。

从对象头的存储内容可以看出锁的状态都保存在对象头中，Synchronized也不例外，当其从轻量级锁膨胀为重量级锁时，锁标识位为10，其中_指针指向的是monitor对象_(也称为管程或监视器锁)的起始地址。

关于Synchronized的实现在java对象头里较为简单，只是改变一下标识位，并将指针指向monitor对象的起始地址，其实现的重点是monitor对象。

在HotSpot虚拟机中，monitor采用ObjectMonitor实现。

内置锁(ObjectMonitor)

通常所说的对象的内置锁，是对象头Mark Word中的重量级锁指针指向的monitor对象，该对象是在HotSpot底层C++语言编写的(openjdk里面看)，简单看一下代码：

1//结构体如下
2ObjectMonitor::ObjectMonitor() {  
3  _header       = NULL;  
4  _count       = 0;  
5  _waiters      = 0,  
6  _recursions   = 0;       //线程的重入次数
7  _object       = NULL;  
8  _owner        = NULL;    //标识拥有该monitor的线程
9  _WaitSet      = NULL;    //等待线程组成的双向循环链表，_WaitSet是第一个节点
10  _WaitSetLock  = 0 ;  
11  _Responsible  = NULL ;  
12  _succ         = NULL ;  
13  _cxq          = NULL ;    //多线程竞争锁进入时的单向链表
14  FreeNext      = NULL ;  
15  _EntryList    = NULL ;    //_owner从该双向循环链表中唤醒线程结点，_EntryList是第一个节点
16  _SpinFreq     = 0 ;  
17  _SpinClock    = 0 ;  
18  OwnerIsThread = 0 ;  
19}

ObjectMonitor队列之间的关系转换可以用下图表示：

既然提到了_waitSet和_EntryList(_cxq队列后面会说)，那就看一下底层的wait和notify方法

wait方法的实现过程:

1  //1.调用ObjectSynchronizer::wait方法
2void ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {
3  /*省略 */
4  //2.获得Object的monitor对象(即内置锁)
5  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
6  DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);
7  //3.调用monitor的wait方法
8  monitor->wait(millis, true, THREAD);
9  /*省略*/
10}
11  //4.在wait方法中调用addWaiter方法
12  inline void ObjectMonitor::AddWaiter(ObjectWaiter* node) {
13  /*省略*/
14  if (_WaitSet == NULL) {
15    //_WaitSet为null，就初始化_waitSet
16    _WaitSet = node;
17    node->_prev = node;
18    node->_next = node;
19  } else {
20    //否则就尾插
21    ObjectWaiter* head = _WaitSet ;
22    ObjectWaiter* tail = head->_prev;
23    assert(tail->_next == head, "invariant check");
24    tail->_next = node;
25    head->_prev = node;
26    node->_next = head;
27    node->_prev = tail;
28  }
29}
30  //5.然后在ObjectMonitor::exit释放锁，接着 thread_ParkEvent->park  也就是wait

总结：通过object获得内置锁(objectMonitor)，通过内置锁将Thread封装成OjectWaiter对象，然后addWaiter将它插入以_waitSet为首结点的等待线程链表中去，最后释放锁。

notify方法的底层实现

1  //1.调用ObjectSynchronizer::notify方法
2    void ObjectSynchronizer::notify(Handle obj, TRAPS) {
3    /*省略*/
4    //2.调用ObjectSynchronizer::inflate方法
5    ObjectSynchronizer::inflate(THREAD, obj())->notify(THREAD);
6}
7    //3.通过inflate方法得到ObjectMonitor对象
8    ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
9    /*省略*/
10     if (mark->has_monitor()) {
11          ObjectMonitor * inf = mark->monitor() ;
12          assert (inf->header()->is_neutral(), "invariant");
13          assert (inf->object() == object, "invariant") ;
14          assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is inva;lid");
15          return inf 
16      }
17    /*省略*/ 
18      }
19    //4.调用ObjectMonitor的notify方法
20    void ObjectMonitor::notify(TRAPS) {
21    /*省略*/
22    //5.调用DequeueWaiter方法移出_waiterSet第一个结点
23    ObjectWaiter * iterator = DequeueWaiter() ;
24    //6.后面省略是将上面DequeueWaiter尾插入_EntrySet的操作
25    /**省略*/
26  }

总结：通过object获得内置锁(objectMonitor)，调用内置锁的notify方法，通过_waitset结点移出等待链表中的首结点，将它置于_EntrySet中去，等待获取锁。注意：notifyAll根据policy不同可能移入_EntryList或者_cxq队列中，此处不详谈。

参考

JVM源码分析之Object.wait/notify实现

[深入理解多线程（四）—— Moniter的实现原理]

从jvm源码看synchronized

并发编程之 wait notify 方法剖析

案例