- 实现一个容器，提供两个方法，add，size，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
- 先看初步版本: 因为notify不会放弃锁，所以最后程序结果不对，因为这个没有放弃锁，所以t2等到t1执行完成后释放锁才执行。
public class MyContainer3 {
// 添加volatile，使t2能够得到通知
volatile List<Integer> list = new ArrayList<>();
public void add(Integer o) {
list.add(o);
}
public int size() {
return list.size();
}
public static void main(String[] args) {
MyContainer3 c = new MyContainer3();
final Object lock = new Object();// 随便创建一个锁
new Thread(() -> {
synchronized (lock) {
System.out.println("t2启动");
if (c.size() != 5) {
try {
lock.wait(); // 放入条件等待队列，放弃当前锁, 被阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
}
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
synchronized (lock) {
for (int i = 0; i < 10; i++) {
c.add(i);
System.out.println("add " + i);
if (c.size() == 5) {
lock.notify(); // 不会放弃当前锁，所以最后程序结果不对，因为这个没有放弃锁，所以t2得不到执行
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
- 解决办法:
notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行；整个通信过程比较繁琐；
public class MyContainer4 {
//添加volatile，使t2能够得到通知
volatile List<Integer> list = new ArrayList<>();
public void add(Integer o) {
list.add(o);
}
public int size() {
return list.size();
}
public static void main(String[] args) {
MyContainer4 c = new MyContainer4();
final Object lock = new Object();
new Thread(() -> {
synchronized (lock) {
System.out.println("t2启动");
if (c.size() != 5) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
//t1释放锁之后，我t2得到了执行，最后我还要通知t1继续执行
lock.notify();
}
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
synchronized (lock) {
for (int i = 0; i < 10; i++) {
c.add(i);
System.out.println("add " + i);
if (c.size() == 5) {
lock.notify();
//再加一个wait(), ---> 释放锁，让t2得以执行
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
- 更高效的方式:
使用Latch（门闩）替代wait notify来进行通知；
好处是通信方式简单，同时也可以指定等待时间；
使用await()和countdown()方法替代wait和notify；
CountDownLatch不涉及锁定(这是和上面不同的，这比上面高效)， 当count的值为零时当前线程继续运行(new CountDownCatch(count))；
当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了；
这时应该考虑countdownlatch/cyclicbarrier/semaphore
代码:
public class MyContainer5 {
//添加volatile，使t2能够得到通知
volatile List<Integer> list = new ArrayList<>();
public void add(Integer o) {
list.add(o);
}
public int size() {
return list.size();
}
public static void main(String[] args) {
MyContainer5 c = new MyContainer5();
CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
System.out.println("t2启动");
if (c.size() != 5) {
try {
latch.await();
//也可以指定等待时间
//latch.await(5000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
for (int i = 0; i < 10; i++) {
c.add(i);
System.out.println("add " + i);
if (c.size() == 5) {
// 打开门闩，让t2得以执行
latch.countDown(); // 调用一次countDown，构造函数中构造的那个值就-1，到了0，门栓就开了(通知t2运行)
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1").start();
}
}
