synchronized和wait()、notify()、notifyAll()的使用

一、关键字及方法的介绍

wait()方法

        用于释放监视器对象的锁，使其休眠、阻塞，等待被唤醒。

notify()方法

        用于唤醒被其中一个阻塞休眠的线程，让该线程去获取监视器对象的锁。

notifyAll()方法

        用于唤醒所有阻塞休眠的线程，让这些线程去竞争监视器对象的锁。

        这三个方法均必须在synchronized修饰的代码块、方法中使用。主要原因如下。每个监视器对象都有两个队列，一个为等待队列，一个为同步队列，调用了wait()方法的线程，会进入等待队列。调用了notify()、notifyAll()方法的，进入同步队列。同步队列中的线程可以去竞争同步锁。

        所以某个线程在执行wait()、notify()、notifyAll()方法时，需要该线程成为该监视器对象的拥有者，获取到锁才可以访问synchronized修饰的代码块，这样才有权限访问该监视器对象的等待队列及同步队列。

synchronized关键字的使用

1. 静态方法修饰，将类的自身作为监视对象（java.lang.Class）,该类使用了synchronized修饰的静态方法，只能被一个线程调用，该监视对象的锁未释放前，其他线程调用会进入阻塞。
2. 类的成员变量，使用类的对象实例作为监视器对象。该类使用了synchronized修饰的方法，只能被一个线程调用，该监视对象的锁未释放前，其他线程调用会进入阻塞。
3. 代码块：使用某个对象作为监视器对象，通常是一个普通的private成员变量，如private Object obj = new Object();，这样所有使用了该ojb对象的同步代码块，在任何时候只能存在一个线程访问。（例如需要加写锁（互斥锁）的对象作为监视器）

二、案例展示（生产消费模型demo）

        通过生产者生产产品，消费者消费产品的demo，解读synchronized关键字的使用，及wait()、notify()、notifyAll()的使用。当然生产消费模型的最佳实现肯定是BlockingQueue，自动阻塞，无需自己调用wait()。

        此处需说明下，synchronized关键字对同一个监视器在多个方法中添加同步代码块需注意顺序，避免死锁。

import java.util.ArrayDeque;
import java.util.Date;
import java.util.Queue;

/**
 * 生产消费模型
 */
public class SyncProConDemo {

    //监视器对象，用于对生产者和消费者进行同步
    private Object monitor;

    //存放产品的队列的容量大小
    private int capacity;

    //存放产品的队列
    private Queue<String> products;


    /**
     *
     * @param monitor 用于同步的监视器
     * @param capacity 存放产品队列的大小
     */
    public SyncProConDemo(Object monitor,int capacity){
        this.capacity = capacity;
        this.monitor = monitor;
        this.products = new ArrayDeque<>(capacity);
    }

    /**
     * 消费者线程消费产品的方法定义，当等待队列不为空时，则取出队列的产品消费
     */
    public void consume(){

        while(true){
            synchronized (monitor){

                while(products.size() == 0){

                    try {
                        System.out.println("产品队列为空，消费者线程于"+(new Date())+"进入等待状态！");
                        monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }

                String product = products.poll();
                System.out.println("消费产品："+product+",消费时间："+new Date());
                monitor.notifyAll();//唤醒生产者生产产品
            }


        }

    }


    /**
     * 生产者线程生产产品方法定义：当队列满时，等待消费者消费产品，当队列不满时，生产产品并填充至队列，同时通知消费者消费。
     */
    public void doProduct(){

        int i=0;
        while(true){
            synchronized (monitor){
                while (products.size() == capacity){

                    try {
                        System.out.println("队列已满，以于"+(new Date())+"暂停生产！");
                        monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println("模拟生产产品，生产日期为："+new Date());
                i++;
                //填充到队列
                products.offer("product"+i);

                //通知消费者消费
                //此处使用notifyAll方法而不是notify方法，避免通知到生产者自身，导致假死现象。
                monitor.notifyAll();
            }

            try {
                Thread.sleep(5000);
                System.out.println();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }


    /**
     * 生产者线程和消费者线程共享同一个生产者消费者模型对象，其中队列容量设置为1.
     * @param args
     */
    public static void main(String[] args) {
        //定义监视器
        Object monitor = new Object();

        SyncProConDemo proConDemo = new SyncProConDemo(monitor,1);

        Thread product = new Thread(new Runnable() {
            @Override
            public void run() {
                proConDemo.doProduct();
            }
        });

        Thread consume = new Thread(new Runnable() {
            @Override
            public void run() {
                proConDemo.consume();
            }
        });
        consume.start();
        product.start();
    }
}

        在并发同步的性能方面，synchronized关键字修复的范围越小，线程并发度越高，性能越好。所以通常使用同步代码块，而不是同步方法来缩小同步范围、优化并发性能。