前言
目前正在出一个Java多线程专题长期系列教程，从入门到进阶含源码解读, 篇幅会较多, 喜欢的话，给个关注❤️ ~
合理的使用多线程能够更好的利用服务器资源，一般来讲，每个线程内部都有自己的上下文，它们之间互不干扰。但是我们有时候需要多个线程之间互相协作，就需要我们掌握线程的通信方式。
锁
首先我们先了解一下锁的概念,之前我们也遇到过，但是没有细讲，今天就把概念理清楚了。在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<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()...这些其实也是这一部分内容，总的来说，它们之间互相协作，具体用法可以看前面的文章，这里就不一一介绍了
结束语
下一节，带大家学习一下Java的内存模型,其实这也是多线程的一部分，一切都是为了铺垫, 等讲到高级概念的时候，听起来就不会那么难了 ~
