线程锁与等待通知机制

synchronized关键词：

在一个多线程程序中，多个线程通过共同协作来完成指定任务。在协作过程中，各个线程通过共享内存的方式来进行通信。一般CPU采用时间片轮转等不同算法来对线程进行调度，这个情况下，一个线程所做的操作对于其它线程并不一定可见，来看代码：

public class IdGenerator {
private int value = 0;
public int getNext() {
return value++;
}
}

上面这一段代码对于一个单线程程序来说，每次对getNext方法的调用都可以保证得到不重复的值。而对于多线程程序来说，却不能保证每次取得的值都不一样。因为上面这一段代码中至少存在取值和赋值两个操作，再具体到cpu指令的话应该会有更多个指令序列，它并不是一个原子操作。

要解决这个问题，我们可以使用关键词synchronized对其添加线程锁:

public class IdGenerator {
private int value = 0;
public synchronized int getNext() {
return value++;
}

public int getNext2() {
synchronized(this) {
return value++;
}
}
}

synchronized关键词可以添加在方法或代码块之上，关键词内包含的代码块在同一时刻只允许有一个线程访问。对于声明为synchronized的方法，静态方法对应的监视器对象是所在Java类对应的Class类的对象所关联的监视器对象，而实例方法使用的是当前对象实例所关联的监视器对象。对于synchronized代码块，对应的监视器对象是synchronized代码块声明中的对象所关联的监视器对象。

volatile关键词：

在Java中，对于long型和double型64位的域的读取和写入操作也不是原子操作，Java一次只能操作32位的数据也就是说，在读取或者写入long和double型的时候也可能会被其它线程所打断。因此在多线程程序中使用long型和double型的共享变量时，需要把变量声明为volatile，以保证读取和写入操作的完整性。如：

volatile double d = 0;

将变量声明为volatile相当于为单个变量的读取和写入添加了同步操作。但是volatile在使用时不需要利用锁机制，因此性能上要优于synchronized关键词。但是在上面的IdGenerator类中，如果只是把value声明为volatile，这样是不够的，因为写入的value的正确值依赖于value的当前值。

等待-通知机制：

Object类中有wait、notify和notifyAll方法：

package java.lang;
public class Object {
...
public final native void notify();
public final native void notifyAll();
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}

if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
timeout++;
}

wait(timeout);
}
public final void wait() throws InterruptedException {
wait(0);
}
...
}

在多线程程序中，单个线程可能会需要满足某些逻辑条件才能继续运行。当线程所要求的条件不满足时，线程进入等待状态，等待由于其他线程的运行而使条件得到满足；其他线程则负责在合适的时机发出通知来唤醒处于等待状态的线程。对于这种场景，可以使用while循环和volatile变量来处理。但是这种做法的本质是让线程处于忙等待的状态，并通过轮询的方式来判断条件是否满足。处于忙等待的线程仍然占用CPU时间，对性能造成影响。更好的做法是使用Object类提供的wait、notify和notifyAll方法：

package com.multithread;

public class maintest {

static private class Lock {}
private static Lock lock = new Lock();

public static void main(String[] args) throws InterruptedException {
Runnable r = new Runnable() {
@Override
public void run() {
synchronized(lock) {
while(true) {
System.out.println("我是R");
try {
lock.wait();
} catch (InterruptedException e) {}
System.out.println("我是R wait之后的代码段");
}
}
}
};
Thread t = new Thread(r);
t.start();

Runnable r1 = new Runnable() {
@Override
public void run() {
synchronized(lock) {
while(true) {
System.out.println("我是R1");
try {
lock.wait();
} catch (InterruptedException e) {}
System.out.println("我是R1 wait之后的代码段");
}
}
}
};
Thread t1 = new Thread(r1);
t1.start();
Thread.currentThread().sleep(1000);
System.out.println("----------------------notify-------------------------");
synchronized(lock) {
System.out.println("获得lock锁");
lock.notify();
}
Thread.currentThread().sleep(1000);
System.out.println("---------------------notifyAll-----------------------");
synchronized(lock) {
System.out.println("获得lock锁");
lock.notifyAll();
}
}
}

运行该段代码，显示结果如下：

我是R
我是R1
----------------------notify-------------------------
获得lock锁
我是R wait之后的代码段
我是R
---------------------notifyAll-----------------------
获得lock锁
我是R wait之后的代码段
我是R
我是R1 wait之后的代码段
我是R1

成功调用wait方法的先决条件是当前线程获取到监视器对象上的锁。如果没有锁，则抛出java.lang.IllegalMonitorStateException异常；如果有锁，那么当前线程被添加到对象所关联的等待集合中，并释放其持有的监视器对象上的锁。当前线程被阻塞，无法继续执行，直到被从对象所关联的等待集合中移除。

对应的notify和notifyAll方法用来通知线程离开等待状态。调用一个对象的notify方法会从该对象关联的等待集合中选择一个线程来唤醒。如果等待集合中有多个线程，具体选择哪个线程唤醒由虚拟机实现来决定，不能保证唤醒的顺序和开发者所预计的一样。而notifyAll则是唤醒等待集合中的所有线程，所以当等待集合中包含多个线程的话，使用notifyAll可以保证程序的正确性，代价是会造成一定的性能影响。

书上只说了wait方法的成功调用需要当前线程持有监视器对象上的锁，因此wait方法的调用需要放在使用synchronized关键词声明的方法或代码块中。但是博主实际测试的结果是notify和notifyAll也必须放到synchronized中。