本文详细介绍了Java中四种线程通信的方法：1) 使用while循环检测条件，但会消耗CPU资源；2) 利用wait和notify配合synchronized关键字实现线程间通信，需注意执行顺序；3) 使用CountDownLatch类实现线程间的实时通信，通过计数器同步；4) 模拟队列实现线程通信，展示了如何在满和空时阻塞线程。
一、使用while方式来实现线程之间的通信
packagecom.ietree.multithread.sync;importjava.util.ArrayList;importjava.util.List;public classMyList {private volatile static List list = newArrayList();public voidadd() {
list.add("apple");
}public intsize() {returnlist.size();
}public static voidmain(String[] args) {final MyList list1 = newMyList();
Thread t1= new Thread(newRunnable() {
@Overridepublic voidrun() {try{for (int i = 0; i < 10; i++) {
list1.add();
System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
Thread.sleep(500);
}
}catch(InterruptedException e) {
e.printStackTrace();
}
}
},"t1");
Thread t2= new Thread(newRunnable() {
@Overridepublic voidrun() {while (true) {if (list1.size() == 5) {
System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + " list size = 5 线程停止..");throw newRuntimeException();
}
}
}
},"t2");
t1.start();
t2.start();
}
}
程序输出：
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
Exception in thread"t2" 当前线程收到通知：t2 list size = 5线程停止..
java.lang.RuntimeException
at com.ietree.multithread.sync.MyList$2.run(MyList.java:43)
at java.lang.Thread.run(Unknown Source)
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
理解：线程Thread2不停地通过while语句检测这个条件(list.size()==5)是否成立 ，从而实现了线程间的通信。但是这种方式会浪费CPU资源。
二、wait notfiy 方法实现多线程中线程之间的通信
使用这种方式实现线程通信需要注意：wait和notify必须配合synchronized关键字使用，wait方法释放锁，notify方法不释放锁。并且在这个例子中必须是Thread2先执行才可以。
packagecom.ietree.multithread.sync;importjava.util.ArrayList;importjava.util.List;public classListAdd3 {private volatile static List list = newArrayList();public voidadd() {
list.add("apple");
}public intsize() {returnlist.size();
}public static voidmain(String[] args) {final ListAdd2 list2 = newListAdd2();//1 实例化出来一个 lock//当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
final Object lock = newObject();
Thread t1= new Thread(newRunnable() {
@Overridepublic voidrun() {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("已经发出通知..");
//不释放锁，遇到size=5时还是继续执行
lock.notify();
}
}
}
}catch(InterruptedException e) {
e.printStackTrace();
}
}
},"t1");
Thread t2= new Thread(newRunnable() {
@Overridepublic voidrun() {synchronized(lock) {if (list2.size() != 5) {try{
//释放锁，让其他线程执行
lock.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");throw newRuntimeException();
}
}
},"t2");
t2.start();
t1.start();
}
}
程序输出：
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t2收到通知线程停止..
Exception in thread"t2"java.lang.RuntimeException
at com.ietree.multithread.sync.ListAdd3$2.run(ListAdd3.java:59)
at java.lang.Thread.run(Unknown Source)
三、使用CountDownLatch类来实现多线程中线程之间的实时通信
packagecom.ietree.multithread.sync;importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.CountDownLatch;public classListAdd2 {private volatile static List list = newArrayList();public voidadd() {
list.add("apple");
}public intsize() {returnlist.size();
}public static voidmain(String[] args) {final ListAdd2 list2 = newListAdd2();final CountDownLatch countDownLatch = new CountDownLatch(1);
Thread t1= new Thread(newRunnable() {
@Overridepublic voidrun() {try{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();
}
}//}
} catch(InterruptedException e) {
e.printStackTrace();
}
}
},"t1");
Thread t2= new Thread(newRunnable() {
@Overridepublic voidrun() {if (list2.size() != 5) {try{
countDownLatch.await();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");throw newRuntimeException();
}
},"t2");
t2.start();
t1.start();
}
}
程序输出：
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
Exception in thread"t2"当前线程：t1添加了一个元素..
当前线程：t2收到通知线程停止..
java.lang.RuntimeException
at com.ietree.multithread.sync.ListAdd2$2.run(ListAdd2.java:56)
at java.lang.Thread.run(Unknown Source)
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
四、使用多线程模拟一个队列
packagecom.ietree.multithread.sync;importjava.util.LinkedList;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.atomic.AtomicInteger;public classMyQueue {//1、定义一个盛装元素集合
private LinkedList list = new LinkedList();//2、定义一个计数器
private AtomicInteger count = newAtomicInteger();//3、指定上限和下限
private final int minSize = 0;private final intmaxSize;//4、构造方法初始化大小
public MyQueue(intsize) {this.maxSize =size;
}//5、初始化一个对象用于加锁
private Object lock = newObject();//put(anObject): 把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断，直到BlockingQueue里面有空间再继续.
public voidput(Object obj) {synchronized(lock) {if (count.get() == this.maxSize) {try{
lock.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}//1、加入元素
list.add(obj);//2、计数器累加
count.incrementAndGet();//3、通知(唤醒)另外一个线程
lock.notify();
System.out.println("新加入的元素为：" +obj);
}
}//take: 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入.
publicObject take() {
Object ret= null;synchronized(lock) {while (count.get() == this.minSize) {try{
lock.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}//1、做移除元素操作
ret =list.removeFirst();//2、计数器作递减操作
count.decrementAndGet();//3、唤醒另外一个操作
lock.notify();
}returnret;
}//获取长度
public intgetSize() {return this.count.get();
}public static voidmain(String[] args) {final MyQueue mq = new MyQueue(5);
mq.put("a");
mq.put("b");
mq.put("c");
mq.put("d");
mq.put("e");
System.out.println("当前容器的长度:" +mq.getSize());
Thread t1= new Thread(newRunnable() {
@Overridepublic voidrun() {
mq.put("f");
mq.put("g");
}
},"t1");
t1.start();
Thread t2= new Thread(newRunnable() {
@Overridepublic voidrun() {
Object o1=mq.take();
System.out.println("移除的元素为:" +o1);
Object o2=mq.take();
System.out.println("移除的元素为:" +o2);
}
},"t2");try{
TimeUnit.SECONDS.sleep(2);
}catch(InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
程序输出：
新加入的元素为：a
新加入的元素为：b
新加入的元素为：c
新加入的元素为：d
新加入的元素为：e
当前容器的长度:5移除的元素为:a
移除的元素为:b
新加入的元素为：f
新加入的元素为：g
扫一扫
1736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
