1、wait/notify方法
package sync;
import java.util.ArrayList;
import java.util.List;
public class WaitAndNotify {
private volatile static List list= new ArrayList();
private void add() {
list.add("wang");
}
private int size() {
return list.size();
}
public static void main(String[] args) {
final WaitAndNotify list1 = new WaitAndNotify();
/*
* 1. 实例化一个Object对象当作锁，下面t1和t2竞争这把锁实现同步
* 2. Object下面会有wait、notify方法，（面试经常问：Object下面有哪些方法，）
* 3. 说明每个对象都有这两个方法，都可以当作锁
*/
final Object lock = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
synchronized (lock) {
for(int i = 0; i < 10; i++) {
list1.add();
System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素");
Thread.sleep(500);
if(list1.size() == 5) {
System.out.println("已经发出通知..");
//notify不释放锁，for循环还会继续执行
lock.notify();
}
}
}
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized(lock) {
/*
* 如果先执行t2线程，如果size不是5，就wait
* wait会释放锁
*/
if(list1.size() != 5) {
try {
System.out.println("t2进入..");
Thread.sleep(3000);
lock.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
//
System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + "list size = 5，线程停止");
throw new RuntimeException();
}
}
}, "t2");
t2.start();
t1.start();
}
}
输出结果：
t2进入.. 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 已经发出通知.. 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程：t1添加了一个元素 当前线程收到通知：t2list size = 5，线程停止 Exception in thread "t2" java.lang.RuntimeException at sync.WaitAndNotify$2.run(WaitAndNotify.java:73) at java.lang.Thread.run(Unknown Source)
代码解读：
第一步：执行t2线程，进入run方法，list.size不等于5，就lock.wait释放锁，t2进程等待，转而执行t1
第二步：执行t1进程，得到锁，执行for循环，当list.size等于5时，发出通知..唤醒t2进程，但是会继续执行完for循环，因为notify不释放锁
第三步：t2进程被唤醒，因此list.size已经等于10，不等于5，直接输出最后两行代码
wait/notify的方式弊端：
t2线程先start，因为其List的size!=5，所以执行lock.wait()释放对象锁，这样在t1线程就可以获得这把lock对象锁。
t1线程向List中添加元素，当List的size==5时，执行lock.notify()，发出唤醒通知，此时t1线程并不释放lock对象锁，所以这时t2虽然收到唤醒的通知，但是由于t1此时并未释放lock对象锁，所以t2只能一直等待，直到t1执行完毕释放lock对象锁，t2才能获取到lock对象锁，执行lock.wait();后面的代码。
2、CountDownLatch方法
下面使用java.util.concurrent包下的类CountDownLatch对上面wait/notify方式的代码进行改造。
CountDownLatch机制不是用来保护共享资源或临界区，而是用来同步一个或多个执行任务的线程。
import java.util.ArrayList; import java.util.List; import java.util.Queue; import java.util.concurrent.CountDownLatch; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.LinkedBlockingQueue; /** * wait notfiy 方法，wait释放锁，notfiy不释放锁 * */ public class ListAdd2 { private volatile static List list = new ArrayList(); public void add(){ list.add("abc"); } public int size(){ return list.size(); } public static void main(String[] args) { final ListAdd2 list2 = new ListAdd2(); // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用 //final Object lock = new Object(); final CountDownLatch countDownLatch = new CountDownLatch(1); Thread t1 = new Thread(new Runnable() { @Override public void run() { try { //synchronized (lock) { for(int i = 0; i <10; i++){ list2.add(); System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素.."); Thread.sleep(500); if(list2.size() == 5){ System.out.println("已经发出通知.."); countDownLatch.countDown(); //lock.notify();//不释放对象锁 } } //} } catch (InterruptedException e) { e.printStackTrace(); } } }, "t1"); Thread t2 = new Thread(new Runnable() { @Override public void run() { //synchronized (lock) { if(list2.size() != 5){ try { //System.out.println("t2进入..."); //lock.wait();//释放对象锁 countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止.."); throw new RuntimeException(); //} } }, "t2"); t2.start();//t2先启动 t1.start(); } }
t2先启动，countDownLatch.await()方法进行阻塞。
t1启动后再运行过程中，当List的size==5时，执行countDownLatch.countDown()发出唤醒通知，
此时，t2接收到通知后，由于没有使用synchronized关键字涉及不到获取锁的问题，因此t2收到通知立即开始执行countDownLatch.await()后面的代码。
在Eclipse中console输出内容如下：
