Java多线程(二)notify,wait,countDownLatch

最新推荐文章于 2024-05-30 12:58:04 发布

weixin_33690367

最新推荐文章于 2024-05-30 12:58:04 发布

阅读量77

点赞数

文章标签： java python

原文链接：https://my.oschina.net/CentralD/blog/1542652

版权

2019独角兽企业重金招聘Python工程师标准>>>

先简单看JDK中对notify和wait的解释：

void notify() 
唤醒在此对象监视器上等待的单个线程

void notifyAll() 
唤醒在此对象监视器上等待的所有线程

void wait( ) 
导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法

void wait(long timeout) 
导致当前的线程等待，直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，或者指定的时间过完。

void wait(long timeout, int nanos) 
导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者其他线程打断了当前线程，或者指定的时间过完。

要注意三个特点：

1.wait( )，notify( )，notifyAll( )都不属于Thread类，而是属于Object基础类，也就是每个对象都有wait( )，notify( )，notifyAll( ) 的功能，因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。

2.wait notfiy 方法，wait释放锁，notfiy不释放锁
3.当使用wait 和 notify 的时候，一定要配合着synchronized关键字去使用.如果不对竞争的资源加锁的话，则会报 IllegalMonitorStateException 异常

先看一个例子：

public class ListAdd1 {


    private volatile static List list = new ArrayList();

    public void add() {
        list.add("number");
    }

    public int size() {
        return list.size();
    }

    public static void main(String[] args) {

        final ListAdd2 list2 = new ListAdd2();

        // 1 实例化出来一个 lock
        // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
        Object lock = new Object();
        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("已经发出通知..");
                                //唤醒
                                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();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
                throw new RuntimeException();
                }
            }
        }, "t2");

        t2.start();
        t1.start();

    }
}
/*
结果：
t2进入...
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
	at com.bjsxt.base.conn008.ListAdd1$2.run(ListAdd1.java:65)
	at java.lang.Thread.run(Thread.java:745)

 */

可以看到，我们先启动t2线程，t2一直处于wait状态。直到t1线程使用notify唤醒t2.但是发现t2被唤醒时，并没有直接停止。而是继续等t1线程执行完成以后才置为唤醒状态。这种方式在某些情况下，需要及时唤醒的情况下，就不满足需求了。

CountDownLatch可以解决以上问题，而且使用的时候不必再加synchronized锁。

public class ListAdd2 {
	private volatile static List list = new ArrayList();	
	
	public void add(){
		list.add("number");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd2 list2 = new ListAdd2();
		
		// 1 实例化出来一个 lock
		// 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
		//final Object lock = new Object();
		//1表示唤醒一次，即可触发countDownLatch.await()
		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();
		t1.start();
		
	}
	
}
/**
 * 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 Exception in thread "t2" java.lang.RuntimeException
 at com.bjsxt.base.conn008.ListAdd2$2.run(ListAdd2.java:73)
 at java.lang.Thread.run(Thread.java:745)
 已经发出通知..
 当前线程：t1添加了一个元素..
 当前线程：t2收到通知线程停止..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 当前线程：t1添加了一个元素..
 */

使用CountDownLatch很好的解决了一个多线程间实时通信的问题。

转载于:https://my.oschina.net/CentralD/blog/1542652