wait notify synchronized 同步zz

wait与notify是java同步机制中重要的组成部分。结合与synchronized关键字使用，可以建立很多优秀的同步模型。

synchronized(this){}等价与public synchronized void method(){.....}

同步分为类级别和对象级别，分别对应着类锁和对象锁。类锁是每个类只有一个，如果static的方法被synchronized关键字修饰，则在这个方法被执行前必须获得类锁；对象锁类同。

首先，调用一个Object的wait与notify/notifyAll的时候，必须保证调用代码对该Object是同步的，也就是说必须在作用等同于synchronized(obj){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法，否则就会报错：

 

java.lang.IllegalMonitorStateException: current thread not owner

        

在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。

所以，notify与notifyAll没有太多的区别，只是notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁，只要是在synchronied块中的代码，没有对象锁是寸步难行的。其实唤醒一个线程就是重新允许这个线程去获得对象锁并向下运行。

顺便说一下notifyall，虽然是对每个wait的对象都调用一次notify，但是这个还是有顺序的，每个对象都保存这一个等待对象链，调用的顺序就是这个链的顺序。其实启动等待对象链中各个线程的也是一个线程，在具体应用的时候，需要注意一下。

 

class ThreadA

{

public static void main(String[] args)

{

ThreadB b=new ThreadB();

b.start();

System.out.println("b is start....");

synchronized(b)//括号里的b是什么意思,起什么作用?

{

try

{

System.out.println("Waiting for b to complete...");

b.wait();//这一句是什么意思，究竟让谁wait?

System.out.println("Completed.Now back to main thread");

}catch (InterruptedException e){}

}

System.out.println("Total is :"+b.total);

}

}

 

 

class ThreadB extends Thread

{

int total;

public void run()

{

synchronized(this)

{ 

System.out.println("ThreadB is running..");

for (int i=0;i<100;i++ )

{

total +=i;

System.out.println("total is "+total);

}

notify();

}

}

}

 

要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.

按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

我们来解释一下这句话.

"wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着,等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.

而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.

但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！

好,那怎么把对象锁收回来呢?

第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.

第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.

那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.

因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

这个时候我们来解释上面的程序,简直是易如反掌了.

synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

 

         再附一段生产者消费者模型的代码：

 

package TestThread;

class SyncStack { // 同步堆栈类
	private int index = 0; // 堆栈指针初始值为0
	private char[] buffer = new char[6]; // 堆栈有6个字符的空间

	public synchronized void push(char c) { // 加上互斥锁
		while (index == buffer.length) { // 堆栈已满，不能压栈
			try {
				this.wait(); // 等待，直到有数据出栈
			} catch (InterruptedException e) {
			}
		}

		this.notify(); // 通知其它线程把数据出栈
		buffer[index] = c; // 数据入栈
		index++; // 指针向上移动
	}

	public synchronized char[] pop() { // 加上互斥锁
		while (index == 0) { // 堆栈无数据，不能出栈
			try {
				this.wait(); // 等待其它线程把数据入栈
			} catch (InterruptedException e) {
			}
		}

		char[] result = new char[index];
		while (index > 0) {
			result[index - 1] = buffer[index - 1];
			index--;
		}
		this.notify(); // 通知其它线程入栈
		return result;
		// index--; // 指针向下移动
		// return buffer[index]; // 数据出栈

	}
}

class Producer implements Runnable { // 生产者类
	SyncStack theStack;

	// 生产者类生成的字母都保存到同步堆栈中

	public Producer(SyncStack s) {
		theStack = s;
	}

	public void run() {
		char c;
		for (int i = 0; i < 26; i++) {
			c = (char) (i + 'A');
			theStack.push(c); // 把字符入栈
			System.out.println("Produced: " + c); // 打印字符
			try {
				Thread.sleep((int) 10000);
				/* 每产生一个字符线程就睡眠 */
			} catch (InterruptedException e) {
			}
		}
	}
}

class Consumer implements Runnable { // 消费者类
	SyncStack theStack;

	// 消费者类获得的字符都来自同步堆栈

	public Consumer(SyncStack s) {
		theStack = s;
	}

	public void run() {
		char[] c;
		for (int i = 0; i < 26; i++) {
			c = theStack.pop(); // 从堆栈中读取字符
			for (char c1 : c) {
				System.out.println("Consumed: " + c1);
				if (c1 == 'Z') {
					return;
				}
			}
			// 打印字符
			try {
				Thread.sleep((int) 1000);
				/* 每读取一个字符线程就睡眠 */
			} catch (InterruptedException e) {
			}
		}
	}
}

public class SyncTest {
	public static void main(String args[]) {
		SyncStack stack = new SyncStack();
		// 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
		Runnable source = new Producer(stack);
		Runnable sink = new Consumer(stack);
		Thread t1 = new Thread(source); // 线程实例化
		Thread t2 = new Thread(sink); // 线程实例化
		t1.start(); // 线程启动
		t2.start(); // 线程启动
	}
}