面试官：说一下线程间的通信

前言

合理的使用多线程能够更好的利用服务器资源，一般来讲，每个线程内部都有自己的上下文，它们之间互不干扰。但是我们有时候需要多个线程之间互相协作，就需要我们掌握线程的通信方式。

锁

首先我们先了解一下锁的概念,之前我们也遇到过，但是没有细讲，今天就把概念理清楚了。在Java多线程中，一把锁在同一时刻只能被一个线程获取，其它线程想要获取它,必须等待该线程释放锁,这时候就牵扯到同步的概念了。因为锁的机制，我们可以使线程可以同步执行，下面以打印数字为例,看下区别。

• 无锁下：

public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            System.out.println("2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

输出:

2
1

而且每次运行的结果都是不一样的。

• 有锁下：

public static final Object lock = new Object();
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        synchronized (lock) {
            System.out.println("1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (lock) {
            System.out.println("2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t1.start();
    t2.start();
}

输出:

1
2

可以看到，无论我执行几次结果都是一样的，而且执行的时候还有等待的效果。

我们这里使用了synchronized关键字，在对象lock上加了一把锁,只有当t1执行完释放掉锁，t2才能获取锁，然后执行。

这里我们需要注意的是，synchronized会不断尝试去获取锁，直到拿到，所以有时候我们程序异常了，记得把锁释放掉，不然会不断消耗服务器资源的。

wait & notify

我们上节带大家了解了wait,notify没有怎么去讲解，现在我们就来说一下。其实这两者是等待通知机制。

• notify()方法会随机叫醒一个正在等待的线程。
• notifyAll()会叫醒所有正在等待的线程。

我们还是通过上面的例子给大家演示一下。

public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();
                    System.out.println("1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
    }

实际输出:

2

发现是先输出2，然后线程就被堵了，1执行不到。大家这里可以猜测一下这个wait的作用是什么。我们大体可以猜到，这个wait其实是做了释放锁的操作，调用之后它进入了等待阶段,t2拿到锁开始执行,这时候t1还在等待，所以我们需要唤醒它。

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        synchronized (lock) {
            try {
                lock.wait();
                System.out.println("1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (lock) {
            System.out.println("2");
            try {
                Thread.sleep(1000);
                // 唤醒当前等待的线程
                lock.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

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

输出：

2
1

发现正常了，有输出。这里大家要注意的是，这个机制需要依赖同一个对象锁,也就是这里的lock对象，底层调用的wait和notify都是native方法。

public final native void wait(long timeout) throws InterruptedException;
  public final native void notify();

信号量

我们也可以通过信号量的方式使线程之间互相协作，这里给大家介绍一下volatile实现的信号量。

• volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

class A {
    //private static volatile int num = 0;
    private static int num = 0;
    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (num < 5) {
                if(num == 4) {
                    System.out.println("threadA: " + num);
                }
            }
        }
    }
    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (num < 5) {
                System.out.println("threadB: " + num);
                num = num + 1;
            }
        }
    }

}
// 运行
public static void main(String[] args) throws InterruptedException {
        new Thread(new A.ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new A.ThreadB()).start();
}

首先这是没加volatile。

threadB: 0
threadB: 1
threadB: 2
threadB: 3
threadB: 4

加volatile。

threadB: 0
threadB: 1
threadB: 2
threadB: 3
threadB: 4
threadA: 5

我们可以发现A可以实时看到num值,并且输出了。

其实我们在使用volatile是需要进行原子操作的，这里只是给大家演示一下，实际中不要这么用。说了这么多，什么场景用呢有时候我们线程有许多个，都需要共享同一资源的时候，使用之前的wait和notify显然有些麻烦，此时我们就可以使用它了。

Channel

其实我们也可以借助管道实现通信，其实这属于IO的知识了。这里给大家简单演示一下,多线程中如何使用,主要借助PipedWriter和PipedReader。

public static void main(String[] args) throws IOException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader);
        Thread t1 = new Thread(() -> {
            int rec = 0;
            try {
                while ((rec = reader.read()) != -1) {
                    System.out.print("\nt1 接收到 ----->" + (char)rec);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                writer.write("hello 我是 t2");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
    }

输出:

t1 接收到 ----->h
t1 接收到 ----->e
t1 接收到 ----->l
t1 接收到 ----->l
t1 接收到 ----->o
t1 接收到 -----> 
t1 接收到 ----->我
t1 接收到 ----->是
t1 接收到 -----> 
t1 接收到 ----->t
t1 接收到 ----->2
进程已结束,退出代码0

ThreadLocal

ThreadLocal是一个本地线程副本变量工具类。内部是一个「弱引用」的Map来维护,它为每个线程都创建一个「副本」，每个线程可以访问自己内部的副本变量,最常用的就是set和get方法了，下面给大家演示一下。

public static void main(String[] args) throws InterruptedException {
    ThreadLocal local = new ThreadLocal<>();
    Thread t1 = new Thread(() -> {
        local.set("t1");
        System.out.println(local.get());
    });
    Thread t2 = new Thread(() -> {
        local.set("t2");
        System.out.println(local.get());
    });
    t1.start();
    t2.start();
}

输出:

t2
t1

其它方式

其实我们之前讲的join(),sleep()...这些其实也是这一部分内容，总的来说，它们之间互相协作，具体用法可以看前面的文章，这里就不一一介绍了。

分享标题：面试官：说一下线程间的通信
浏览地址：http://www.zsjierui.cn/article/dphihgj.html