wait和notify

多线程是需要同步协作，比如QuartzSchedulerThread，作为Quartz的任务调度线程，如果设置该线程暂停，那么这个线程就必须wait, 等外界通知继续的时候，再执行任务。

// check if we're supposed to pause...

synchronized (sigLock) {

while (paused && !halted.get()) {

try {

// wait until togglePause(false) is called...

//使当前线程暂停1秒

sigLock.wait(1000L);

} catch (InterruptedException ignore) {

}

}

if (halted.get()) {

break;

}

}

如果要调用对象的wait方法，就必须先获得这个对象的锁–>synchronized (sigLock)。

当线程执行了wait后，就释放了锁，这样当线程在wait期间，QuartzScheduler就有机会获得锁。然后就可以执行唤醒操作notify。

如果多个线程都在wait sigLock, 当调用 notify的时候只能唤醒其中一个线程(由JVM决定)，调用notifyAll则能唤醒全部线程。

从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。

相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

QuartzScheduler执行start方法，会调用schedThread.togglePause(false); 取消QuartzSchedulerThread的暂停，初始化的时候QuartzSchedulerThread的pause是true

。

void togglePause(boolean pause) {

synchronized (sigLock) {

paused = pause;

if (paused) {

signalSchedulingChange(0);

} else {

sigLock.notifyAll();

}

}

}

sleep 和 wait 的区别

Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

经典的ABC打印问题

建立三个线程，A线程打印10次A，B线程打印10次B, C线程打印10次C，要求线程同时运行，交替打印10次ABC。

public class MyThreadPrinter2 implements Runnable {

private String name;

private Object prev;

private Object self;

private MyThreadPrinter2(String name, Object prev, Object self) {

this.name = name;

this.prev = prev;

this.self = self;

}

@Override

public void run() {

int count = 10;

while (count > 0) {

synchronized (prev) {

synchronized (self) {

System.out.print(name);

count--;

self.notify();

}

try {

prev.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public static void main(String[] args) throws Exception {

Object a = new Object();

Object b = new Object();

Object c = new Object();

MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);

MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);

MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);

new Thread(pa).start();

new Thread(pb).start();

new Thread(pc).start(); }

}

A—>B—>C—>A

要想控制线程执行的顺序，就需要使用锁机制，每个线程都持有自己的锁，并且在自己上一个线程的锁释放的时候才能执行。

比如B执行的条件：

1. A 锁释放

2. 获得自己的B 锁

A执行的条件：

1. C锁释放

2. 获得自己的A 锁

执行流程：

1. 获得前一个线程的锁 synchronized (prev)

2. 获得自己的锁，执行方法，释放自己的锁，通知下一个线程 synchronized (self) { self.notify(); }

3. 释放前一个线程的锁，继续监听锁，prev.wait();

总结：

wait就是监听锁对象，将当前线程放入锁的等待队列中。

notify就是通知监听线程，告诉监听该锁的线程，你们可以获得锁了。

notify只会让其中一个监听线程执行，由JVM决定。notifyAll会通知所有的监听线程。

那么问题来了！

如果A 执行了System.out.print(name);方法后，CPU又切换到了主线程。启动了B 和C 线程，

B 获取不到A锁，继续等待。C 获得了B锁，然后准备获得自己的C锁，这时A居然执行完成了，释放了C锁，所以C就可以执行方法了。 然后就是落后的B，先获得A锁，再获得B锁，执行。

就成了ACBACB…..

模拟代码：

public void run() {

int count = 10;

while (count > 0) {

synchronized (prev) {

synchronized (self) {

System.out.print(name);

count--;

try{

//先睡会，CPU你去找其他线程

Thread.sleep(1);

}

catch (InterruptedException e){

e.printStackTrace();

}

self.notify();

}

try {

prev.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

解决：

public class MyThreadPrinter2 implements Runnable {

private String name;

private Object prev;

private Object self;

private MyThreadPrinter2(String name, Object prev, Object self) {

this.name = name;

this.prev = prev;

this.self = self;

}

@Override

public void run() {

int count = 10;

while (count > 0) {

synchronized (prev) {

synchronized (self) {

System.out.print(name);

count--;

try{

Thread.sleep(1);

}

catch (InterruptedException e){

e.printStackTrace();

}

self.notify();

}

try {

prev.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public static void main(String[] args) throws Exception {

Object a = new Object();

Object b = new Object();

Object c = new Object();

MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);

MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);

MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);

new Thread(pa).start();

//使主线程睡眠，这样CPU就不会在A执行结束前去执行B或者C，给A足够的时间完成调度。

Thread.sleep(10);

//主线程睡眠之间到了时候，恢复CPU调度，启动线程B

new Thread(pb).start();

Thread.sleep(10);

new Thread(pc).start();

Thread.sleep(10);

}

}

synchronized的4种用法

1.方法声明

public synchronized void synMethod() {

//方法体

}

一次只能一个线程进入该方法。

2.对某一代码块使用

public int synMethod(int a1){

synchronized(a1) {

//一次只能有一个线程进入

}

}

文章来自