wait/notify()关键字适用于一个线程通知另一个线程所需的条件状态已就绪,最常用于线程在循环中休眠直到获取特定条件的场景. 例如,一个线程一直等待直到队列中有一个组件能够处理;当组件添加到队列时,另一个线程能够唤醒这个等待的线程。

如下代码演示线程间的协作:

package thread_waitnotify; 
 
public class ProductFactory { 
    class Worker implements Runnable { 
        private final Object lockObject = new Object(); 
        private volatile boolean hasWork = false; 
 
        private void waitTakeTask() { 
            synchronized (lockObject) { 
                while (!hasWork) { 
                    try { 
                        System.out.println("等待中..."); 
                        lockObject.wait(); 
                    } catch (InterruptedException e) { 
                        e.printStackTrace(); 
                    } 
                } 
                takeTask(); 
            } 
        } 
 
        private void takeTask() { 
            boolean tmpHasWork = false; 
            synchronized (lockObject) { 
                if (hasWork) 
                    tmpHasWork = true; 
            } 
            if (tmpHasWork) { 
                System.out.println("开始做任务..."); 
                try { 
                    Thread.sleep(3000); 
                    synchronized (lockObject) { 
                        hasWork = false; 
                    } 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
 
                System.out.println("任务完成,休息3s后退出..."); 
                try { 
                    Thread.sleep(3000); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
 
                // System.out.println("任务完成,继续寻找下一项任务..."); 
                // takeTask(); 
            } else { 
                System.out.println("暂时没有任务,进入等待状态..."); 
                waitTakeTask(); 
            } 
        } 
 
        public void notifyChange() { 
            synchronized (lockObject) { 
                hasWork = true; 
                System.out.println("起床开工了..."); 
                lockObject.notifyAll();// 唤醒所有等待获取lockObject锁的线程 
            } 
        } 
 
        @Override 
        public void run() { 
            takeTask(); 
        } 
    } 
 
    public static void main(String[] args) throws InterruptedException { 
 
        Worker worker = new ProductFactory().new Worker(); 
        Thread thread = new Thread(worker); 
        thread.start(); 
        Thread.sleep(3000);// 主线程休眠3s后唤醒子线程 
        worker.notifyChange();// 主线程设置子线程中的信号量并唤醒阻塞的线程 
 
        thread.join();// 主线程阻塞,等待子线程执行完成后继续主线程的执行 
        System.out.println("子线程执行完成,主线程退出。"); 
        System.exit(0); 
    } 
 
}

执行结果如下所示:

说一下synchronized和wait()、notify()的关系:

1.有synchronized的地方不一定有wait,notify

2.有wait,notify的地方必有synchronized.这是因为wait和notify不是属于线程类,而是每一个对象都具有的方法,而且,这两个方法都和对象锁有关,有锁的地方,必有synchronized。


评论关闭
IT干货网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

使用bootstrapvalidator的remote验证经验