Java并发包——线程通信

Java并发包——线程通信

摘要：本文主要学习了Java并发包里有关线程通信的一些知识。

部分内容来自以下博客：

https://www.cnblogs.com/skywang12345/p/3496716.html

线程通信方式

对于线程之间的通信方式，我们之前使用Object.wait()和Object.notify()，通过与synchronized关键字进行同步，两者配合使用，可以实现线程之间的通信。

后来在JUC并发包里发现可以使用Lock取代synchronized关键字实现线程之间的同步，并且使用Lock的方式有比synchronized方式更加强大的功能，为了同Lock配合，实现线程之间的通信，就要用到Condition。

Condition的作用是对锁进行更精确的控制。Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的wait()、notify()、notifyAll()方法是和“同步锁”（synchronized关键字）捆绑使用的，而Condition是需要与“独享锁/共享锁”捆绑使用的。

使用Condition的优势

能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。

能够在多个线程之间进行通信。Object的wait()、notify()、notifyAll()方法只能实现两个线程之间的通信，而Lock对象能通过newCondition()方法创建出无数的“条件”，通过这些条件，我们就能够成功地实现多线程之间的数据通信，对它们进行控制。

Condition

Condition是java.util.concurrent.locks包下的一个接口，提供了用来进行线程通信的方法。

public interface Condition {
    // 使当前线程加入等待队列中并释放当锁，被通知、被中断时唤醒。
    void await() throws InterruptedException;

    // 同await()类似，只是该方法对中断不敏感，只有被通知时才被唤醒。
    void awaitUninterruptibly();

    // 同await()类似，如果在指定时间之内没有被通知或者被中断，该方法会返回false。
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    // 当前线程进入等待状态，被通知、中断或者超时之后被唤醒。返回值就是表示剩余的时间，超时返回值是0或者负数。
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    // 同awaitNanos(long nanosTimeout)类似，只是参数变成了指定日期。
    boolean awaitUntil(Date deadline) throws InterruptedException;

    // 唤醒一个在等待队列中的线程。
    void signal();

    // 唤醒所有在等待队列中的线程。
    void signalAll();
}

获取Lock上的特定Condition

Condition实例实质上被绑定到一个锁上。一个锁内部可以有多个Condition，即有多路等待和通知。要为特定Lock实例获得Condition实例，请使用Lock的newCondition()方法。

newCondition()返回用来与当前Lock实例一起使用的Condition实例。

类似于Object.wait()和Object.notify()的功能，Object.wait()与Object.notify()需要结合synchronized使用。Condition需要结合ReentrantLock使用。

使用Condition实现线程通信

使用synchronized和Object类的方法

使用synchronized和Object类的方法实现两个线程交替打印，代码如下：

public class Demo {
    public static void main(String[] args) {
        DemoThread demoThread = new DemoThread();
        Thread a = new Thread(demoThread, "线程A");
        Thread b = new Thread(demoThread, "线程B");
        a.start();
        b.start();
    }
}

class DemoThread implements Runnable {
    private Integer num = 1;

    @Override
    public void run() {
        synchronized (DemoThread.class) {
            while (num <= 10) {
                DemoThread.class.notify();
                System.out.println(Thread.currentThread().getName() + " >>> " + num++);
                if (num <= 10) {
                    try {
                        DemoThread.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

运行结果如下：

线程A >>> 1
线程B >>> 2
线程A >>> 3
线程B >>> 4
线程A >>> 5
线程B >>> 6
线程A >>> 7
线程B >>> 8
线程A >>> 9
线程B >>> 10

使用Lock和Condition类的方法

使用Lock和Condition类的方法实现两个线程交替打印，代码如下：

public class Demo {
    public static void main(String[] args) {
        DemoThread demoThread = new DemoThread();
        Thread a = new Thread(demoThread, "线程A");
        Thread b = new Thread(demoThread, "线程B");
        a.start();
        b.start();
    }
}

class DemoThread implements Runnable {
    private Integer num = 1;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    @Override
    public void run() {
        lock.lock();
        try {
            while (num <= 10) {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + " >>> " + num++);
                if (num <= 10) {
                    condition.await();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果如下：

线程A >>> 1
线程B >>> 2
线程A >>> 3
线程B >>> 4
线程A >>> 5
线程B >>> 6
线程A >>> 7
线程B >>> 8
线程A >>> 9
线程B >>> 10

使用Lock和Condition类的方法实现三个线程按顺序循环打印

使用Lock和Condition类的方法实现三个线程按顺序打印，需要唤醒指定的线程，代码如下：

public class Demo {
    public static void main(String[] args) {
        DemoThread demoThread = new DemoThread();
        Thread a = new Thread(() -> demoThread.run1(), "线程1");
        Thread b = new Thread(() -> demoThread.run2(), "线程2");
        Thread c = new Thread(() -> demoThread.run3(), "线程3");
        a.start();
        b.start();
        c.start();
    }
}

class DemoThread {
    static private Integer num = 0;
    static Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();

    public void run1() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        lock.lock();
        try {
            while (num < 10) {
                for (int i = 0; i < 1 && num < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " >>> " + num);
                }
                num++;
                c2.signal();
                c1.await();
                if (num >= 9) {
                    c3.signal();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void run2() {
        try {
            Thread.sleep(20);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        lock.lock();
        try {
            while (num < 10) {
                for (int i = 0; i < 2 && num < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " >>> " + num);
                }
                num++;
                c3.signal();
                c2.await();
                if (num >= 9) {
                    c1.signal();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void run3() {
        try {
            Thread.sleep(30);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        lock.lock();
        try {
            while (num < 10) {
                for (int i = 0; i < 3 && num < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " >>> " + num);
                }
                num++;
                c1.signal();
                c3.await();
                if (num >= 9) {
                    c2.signal();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果如下：

线程1 >>> 0
线程2 >>> 1
线程2 >>> 1
线程3 >>> 2
线程3 >>> 2
线程3 >>> 2
线程1 >>> 3
线程2 >>> 4
线程2 >>> 4
线程3 >>> 5
线程3 >>> 5
线程3 >>> 5
线程1 >>> 6
线程2 >>> 7
线程2 >>> 7
线程3 >>> 8
线程3 >>> 8
线程3 >>> 8
线程1 >>> 9

Condition中的await()、signal()、signalAll()与Object中的wait()、notify()、notifyAll()区别

使用方式不同

Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。

不同的是，Object中的这些方法是和同步锁捆绑使用的，而Condition是需要与互斥锁/共享锁捆绑使用的。

功能更加强大

Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。

例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒“读线程”。当从缓冲区读出数据之后，唤醒“写线程”。当缓冲区满的时候，“写线程”需要等待。当缓冲区为空时，“读线程”需要等待。

如果采用Object类中的wait()、notify()、notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒“读线程”时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程，但是notifyAll无法区分唤醒的线程是读线程，还是写线程。

但是，通过Condition，就能明确的指定唤醒读线程。