淘宝面试题
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 分析下面这个程序，能完成这个功能吗？
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T01_WithoutVolatile {
List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T01_WithoutVolatile c = new T01_WithoutVolatile();
new Thread(() -> {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1").start();
new Thread(() -> {
while(true) {
if(c.size() == 5) {
break;
}
}
System.out.println("t2 结束");
}, "t2").start();
}
}
这很明显不能，因为两个线程之间存在不可见效。
使用violate和synchronized来解决（假如去掉了睡眠，程序就失效的原因：violate只能保证锁的引用有效，对于引用的属性则不能保证可见性）
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，
* 而且，如果在if 和 break之间被别的线程打断，得到的结果也不精确，
* 该怎么做呢？
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T02_WithVolatile {
//添加volatile，使t2能够得到通知
//volatile List lists = new LinkedList();
volatile List lists = Collections.synchronizedList(new LinkedList<>());
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T02_WithVolatile c = new T02_WithVolatile();
new Thread(() -> {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
/*try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
}, "t1").start();
new Thread(() -> {
while(true) {
if(c.size() == 5) {
break;
}
}
System.out.println("t2 结束");
}, "t2").start();
}
}
发现结果没有达到预期的根本原因：t1的notify不释放锁，t2只进行了等待操作，没有获取到锁操作
解决办法：代码如下
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T04_NotifyFreeLock {
//添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T04_NotifyFreeLock c = new T04_NotifyFreeLock();
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继续执行
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(new Object());
System.out.println("add " + i);
if(c.size() == 5) {
lock.notify();
//释放锁，让t2得以执行
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
使用CountDownLatch来进行操作。使用两把门栓来进行操作，防止t1count的值为零时当前线程继续运行，而t2线程才开始打印。
/* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
*
* 使用Latch（门闩）替代wait notify来进行通知
* 好处是通信方式简单，同时也可以指定等待时间
* 使用await和countdown方法替代wait和notify
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
* 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
* 这时应该考虑countdownlatch/cyclicbarrier/semaphore
* @author mashibing
*/
package juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class T05_CountDownLatch {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T05_CountDownLatch c = new T05_CountDownLatch();
CountDownLatch latch = new CountDownLatch(1);
CountDownLatch latchNew = 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();
}
}
latchNew.countDown();
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(new Object());
System.out.println("add " + i);
if (c.size() == 5) {
// 打开门闩，让t2得以执行
latch.countDown();
try {
latchNew.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// try {
// TimeUnit.SECONDS.sleep(1);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
}
}, "t1").start();
}
}
最简单的办法使用LockSupport
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
*
* 使用Latch（门闩）替代wait notify来进行通知
* 好处是通信方式简单，同时也可以指定等待时间
* 使用await和countdown方法替代wait和notify
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
* 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
* 这时应该考虑countdownlatch/cyclicbarrier/semaphore
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
//TODO park unpark
public class T07_LockSupport_WithoutSleep {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
static Thread t1 = null, t2 = null;
public static void main(String[] args) {
T07_LockSupport_WithoutSleep c = new T07_LockSupport_WithoutSleep();
t1 = new Thread(() -> {
System.out.println("t1启动");
for (int i = 0; i < 10; i++) {
c.add(new Object());
System.out.println("add " + i);
if (c.size() == 5) {
LockSupport.unpark(t2);
LockSupport.park();
}
}
}, "t1");
t2 = new Thread(() -> {
//System.out.println("t2启动");
//if (c.size() != 5) {
LockSupport.park();
//}
System.out.println("t2 结束");
LockSupport.unpark(t1);
}, "t2");
t2.start();
t1.start();
}
}