前言
合理的使用多线程能够更好的利用服务器资源，一般来讲，每个线程内部都有自己的上下文，它们之间互不干扰。但是我们有时候需要多个线程之间互相协作，就需要我们掌握线程的通信方式。
锁
首先我们先了解一下锁的概念,之前我们也遇到过，但是没有细讲，今天就把概念理清楚了。在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 {
public void run() {
while (num < 5) {
if(num == 4) {
System.out.println("threadA: " + num);
}
}
}
}
static class ThreadB implements Runnable {
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<String> 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()...这些其实也是这一部分内容，总的来说，它们之间互相协作，具体用法可以看前面的文章，这里就不一一介绍了。
