线程在操作系统中是独立的个体，为了使独立的线程成为整体，来由程序员哥哥对各线程任务在处理过程中进行有效的把控与监督，让他们彼此之间可以互相通信和协作，从而使系统之间的交互性更强大。
不使用等待通信的机制
package com.example.test;
import java.util.ArrayList;
import java.util.List;
public class Test209 {
private List<String> list = new ArrayList();
public void add(String value) {
list.add(value);
}
public int getSize() {
return list.size();
}
public static void main(String[] args) {
Test209 t = new Test209();
Test209Thread tt = new Test209Thread(t);
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
package com.example.test;
import java.util.List;
public class Test209Thread implements Runnable{
private Test209 t;
public Test209Thread(Test209 t) {
super();
this.t = t;
}
@Override
public void run() {
// TODO Auto-generated method stub
if(Thread.currentThread().getName().equals("t1")) {
for(int i =0;i<10;i++) {
t.add("枪仔");
System.out.println("我添加"+(i+1)+"个元素");
}
}else {
while(true) {
if(t.getSize()==5) {
System.out.println("我退出了"+Thread.currentThread().getName());
try {
throw new Exception();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
}
我们通过while不断轮询查看是否满足条件，可以这样的例子会有问题，加入添加的线程如果一下子作为添加，而另外一个线程还没有获得执行权，那么该线程拥有停不下来。而且这种轮询机制很费CPU资源。
等待/通知机制理解
等待通知机制在生活中比比皆是，比如在就餐时就会出现，厨师和服务员之间的交互要在“菜品传递台”上，在这期间会有几个问题:
1)厨师做完一道菜的时间不确定，所以厨师将菜品放到“菜品传递台”上的时间也不确定。
2 )服务员取到菜的时间取决于厨师，所以服务员就有“等待”(wait) 的状态。
3 )服务员如何能取到菜呢? 这又得取决于厨师，厨师将菜放在“菜品传递台”上，其实就相当于一种通知(notify),这时服务员才可以拿到菜并交给就餐者。
4 )在这个过程中出现了“等待/通知”机制。
等待/通知机制
方法wait()的作用是使当前执行代码的线程进行等待，wait方法 是 Object 类的方法，该方法用来将当前线程置入“预执行以列”中，并且在wait()所在的代码行处停止执行，直到接到通知成被中断为止。在调用wait()之前，线程必须获得该对的对象级别锁，即只能在同步方法或同步块中调用wait()方法。*在执行wait()方法后，当前线程释放锁。在wait()返回前，程与其他线程竞争重新获得锁。如果调用wait()时没有持有适当的锁，则抛出llegalMonitorStateExction，获得锁之后，是继续程序终止的位置继续执行。*
比较大的坑
在这里我要补上遇到的一个坑，在调用wait()之前，线程必须获得该对的对象级别锁，这句话千万不能小看了，隐藏了大的杀鸡，我在后面的join的例子中，join底层是通过wait让子线程先执行，所以调用wait之后，会释放锁，我操，本来简单的问题，就是想不通，我是自己创建了一个对象锁，我草，怎么就执行不了其他拥有同一个锁的方法，怪我理解的不够透彻，join方法是由线程调用，释放是该线程对象的锁，不是我自己创建同步锁，所以怎么执行通过。
方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify() 时没有持有适当的锁，也会抛出IlegalMonitorStateException 该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程（这个线程必须和notify所持有的线程的锁是同一个对象），对其发出通知notify,并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait 状态的线程也并不能马上获取该对象锁，要等到执行noify()方法的线程将程序执行完，也就是退出synchronized 代码块后，当前线程才会释放锁而呈wait 状态所在的线程才可以获取该对象锁。*当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify 语句，则即便该对象已经空闲，其他wait 状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait 状态，直到这个对象发出一个notify 或notifyAll。*
wait异常
String s = new String();
try {
s.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}出现异常的原因是没有对象监视器，没有同步加锁。
等待通知实例
上面那个通过往list添加，当容量等于5，发出通知的例子，通过wait、notify，做如下的修改即可：
synchronized (o) {
if(Thread.currentThread().getName().equals("t1")) {
for(int i =0;i<10;i++) {
if(t.getSize()==5) {
System.out.println("同志们这是第5个了，需要注意了");
}
t.add("枪仔");
System.out.println("我添加"+(i+1)+"个元素");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}else {
if(t.getSize()!=5) {
try {
System.out.println("我是wait之上");
o.wait();
System.out.println("我是wait之下");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}wait()锁释放
synchronized (o) {
System.out.println(Thread.currentThread().getName()+"wait 上");
try {
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"wait 下");
}运行结果：wait方法执行后，会立即释放锁，并且从当前的运行状态退出，进入阻塞（等待）状态。
notify方法
线程执行notify方法之后，不会立即释放锁，要等整个synchronized代码块执行后才释放。该方法执行之后，会随机将等待wait状态的线程进行唤醒。
由于多次调用notify方法也可以实现唤醒其他线程，但不能系统中所有的，会出现部分线程对象无法唤醒的情况。为了全部唤醒形成，可以使用notifyAll()方法。
public class Test220 {
public static void main(String[] args) {
MyThread220 mt = new MyThread220();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
Thread t4 = new Thread(mt);
t4.setName("t1");
t1.start();
t2.start();
t3.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t4.start();
}
}
class MyThread220 implements Runnable{
private Object o = new Object();
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (o) {
if(Thread.currentThread().getName().equals("t1")) {
o.notifyAll();
}else {
try {
System.out.println(Thread.currentThread().getName()+"up");
o.wait();
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()+"down");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}使用notifyAll方法，其实每次还是先唤醒一个，执行结束，在唤醒其他的，不是一下子就全部OK的。因为唤醒的那些都是同一把锁，必须执行同步。
wait（long time）
该方法是等待某一段时间是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒。
public class Test221 {
public static void main(String[] args) {
MyThread221 mt = new MyThread221();
Thread t = new Thread(mt);
t.start();
}
}
class MyThread221 implements Runnable{
private Object o = new Object();
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (o) {
System.out.println("up");
try {
o.wait(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("down");
}
}
}
通知过早
public class Test223 {
static Object lock = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
System.out.println("wait start");
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("wait end");
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
System.out.println("notify start");
lock.notify();
System.out.println("notify end");
}
// TODO Auto-generated method stub
}
});
t2.start();
t1.start();
}
}
从运行的结果，可以看出通知线程先执行完，那么等待的线程获取不到通知，将一直等待，整个程序就陷入死循环。
wait条件的改变
package com.example.test;
import java.util.ArrayList;
import java.util.List;
public class Test224 {
private Object lock;
private List list;
public Test224(Object lock, List list) {
super();
this.lock = lock;
this.list = list;
};
public void add() {
synchronized (lock) {
list.add("laoqiang");
System.out.println("我已经添加了一个");
lock.notifyAll();
}
}
public void subNumber() {
synchronized (lock) {
if(list.size()==0) {
System.out.println("执行几次循环");
System.out.println("wait start"+Thread.currentThread().getName());
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("wait end"+Thread.currentThread().getName());
}
list.remove(0);
}
}
public static void main(String[] args) {
List list = new ArrayList<>();
Object lock = new Object();
Test224 t224 = new Test224(lock, list);
Thread t1= new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
t224.add();
}
});
t1.setName("t1 add");
Thread t2= new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
t224.subNumber();
}
});
t2.setName("t2 sub");
t2.start();
Thread t3= new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
t224.subNumber();
}
});
t3.setName("t3 sub");
t3.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t1.start();
}
}
看到这个运行结果，应该知道问题出在哪里，等待线程有两个，一旦得到通知，就会执行删除，但是需要注意的是，每次只是添加一个，删除一个后，另外的一个线程删除就会有问题。
为了解决上述的问题，我们将代码做了如下的修改：
while(list.size()==0) {
System.out.println("wait start"+Thread.currentThread().getName());
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("wait end"+Thread.currentThread().getName());
}
list.remove(0);细心的朋友，发现我们只是将if该成while，为啥子可以呢，if的条件判断只是执行一次，而while条件判断，只要满足就继续执行，所以当第一个线程执行完成之后，另外一个线程从wait的地方执行，执行之后判断，发现list.size为0，继续循环等待，所以巧妙的使用while来避开上述的问题。
补充
在多个线程执行的时候，如果一个线程wait之后，其他准备好了的线程是可以执行的。如果发出一个notify之后，那么之前wait线程，是具有优先性的，比正常在等待的要更优先执行。
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
