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

前言

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

锁

首先我们先了解一下锁的下线信概念,之前我们也遇到过，但是程间没有细讲，今天就把概念理清楚了。面试在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 {

ThreadLocallocal = 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()...这些其实也是这一部分内容，总的来说，它们之间互相协作，具体用法可以看前面的文章，这里就不一一介绍了。