java多线程文章

java多线程之线程创建和状态

java多线程之FutureTask、Future、CompletableFuture

java多线程之线程池

java多线程之线程通信工具类

 

合理的使⽤Java多线程可以更好地利⽤服务器资源。⼀般来讲，线程内部有⾃⼰私 有的线程上下⽂，互不⼲扰。但是当我们需要多个线程之间相互协作的时候，就需 要我们掌握Java线程的通信⽅式。本⽂将介绍Java线程之间的⼏种通信原理。

一、锁与同步

在Java中，锁的概念都是基于对象的，所以我们⼜经常称它为对象锁。线程和锁的 关系，我们可以⽤婚姻关系来理解。⼀个锁同⼀时间只能被⼀个线程持有。也就是 说，⼀个锁如果和⼀个线程“结婚”（持有），那其他线程如果需要得到这个锁，就 得等这个线程和这个锁“离婚”（释放）。

在我们的线程之间，有⼀个同步的概念。什么是同步呢，假如我们现在有2位正在 抄暑假作业答案的同学：线程A和线程B。当他们正在抄的时候，⽼师突然来修改 了⼀些答案，可能A和B最后写出的暑假作业就不⼀样。我们为了A,B能写出2本相 同的暑假作业，我们就需要让⽼师先修改答案，然后A，B同学再抄。或者A，B同 学先抄完，⽼师再修改答案。这就是线程A，线程B的线程同步。 可以以解释为：线程同步是线程之间按照⼀定的顺序执⾏。

为了达到线程同步，我们可以使⽤锁来实现它。 我们先来看看⼀个⽆锁的程序：

public class NoneLock {static class ThreadA implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("Thread A " + i);}}}static class ThreadB implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("Thread B " + i);}}}public static void main(String[] args) {new Thread(new ThreadA()).start();new Thread(new ThreadB()).start();}
}

执⾏这个程序，你会在控制台看到，线程A和线程B各⾃独⽴⼯作，输出⾃⼰的打 印值。如下是我的电脑上某⼀次运⾏的结果。每⼀次运⾏结果都会不⼀样。

想等A先执⾏完之后，再由B去执⾏，怎么办呢？最简单 的⽅式就是使⽤⼀个“对象锁”：

public class ObjectLock {private static Object lock = new Object();static class ThreadA implements Runnable {@Overridepublic void run() {synchronized (lock) {for (int i = 0; i < 100; i++) {System.out.println("Thread A " + i);}}}}static class ThreadB implements Runnable {@Overridepublic void run() {synchronized (lock) {for (int i = 0; i < 100; i++) {System.out.println("Thread B " + i);}}}}public static void main(String[] args) throws InterruptedException {new Thread(new ThreadA()).start();Thread.sleep(10);new Thread(new ThreadB()).start();}
}

这⾥声明了⼀个名字为 lock 的对象锁。我们在 ThreadA 和 ThreadB 内需要同步的 代码块⾥，都是⽤ synchronized 关键字加上了同⼀个对象锁 lock 。 上⽂我们说到了，根据线程和锁的关系，同⼀时间只有⼀个线程持有⼀个锁，那么 线程B就会等线程A执⾏完成后释放 lock ，线程B才能获得锁 lock 。

注 : 这⾥在主线程⾥使⽤sleep⽅法睡眠了10毫秒，是为了防⽌线程B先得到锁。 因为如果同时start，线程A和线程B都是出于就绪状态，操作系统可能会先让 B运⾏。这样就会先输出B的内容，然后B执⾏完成之后⾃动释放锁，线程A 再执⾏。

二、等待/通知机制

上⾯⼀种基于“锁”的⽅式，线程需要不断地去尝试获得锁，如果失败了，再继续尝 试。这可能会耗费服务器资源。 ⽽等待/通知机制是另⼀种⽅式。 Java多线程的等待/通知机制是基于 Object 类的 wait() ⽅法和 notify() , notifyAll() ⽅法来实现的。

notify()⽅法会随机叫醒⼀个正在等待的线程，⽽notifyAll()会叫醒所有正在等 待的线程。

前⾯我们讲到，⼀个锁同⼀时刻只能被⼀个线程持有。⽽假如线程A现在持有了⼀ 个锁 lock 并开始执⾏，它可以使⽤ lock.wait() 让⾃⼰进⼊等待状态。这个时 候， lock 这个锁是被释放了的。 这时，线程B获得了 lock 这个锁并开始执⾏，它可以在某⼀时刻，使 ⽤ lock.notify() ，通知之前持有 lock 锁并进⼊等待状态的线程A，说“线程A你不 ⽤等了，可以往下执⾏了”。

需要注意的是，这个时候线程B并没有释放锁 lock ，除⾮线程B这个时候使 ⽤ lock.wait() 释放锁，或者线程B执⾏结束⾃⾏释放锁，线程A才能得 到 lock 锁。

public class WaitAndNotify {private static Object lock = new Object();static class ThreadA implements Runnable {@Overridepublic void run() {synchronized (lock) {for (int i = 0; i < 5; i++) {try {System.out.println("ThreadA: " + i);lock.notify();lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}lock.notify();}}}static class ThreadB implements Runnable {@Overridepublic void run() {synchronized (lock) {for (int i = 0; i < 5; i++) {try {System.out.println("ThreadB: " + i);lock.notify();lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}lock.notify();}}}public static void main(String[] args) throws InterruptedException {new Thread(new ThreadA()).start();Thread.sleep(1000);new Thread(new ThreadB()).start();}
}

结果

ThreadA: 0
ThreadB: 0
ThreadA: 1
ThreadB: 1
ThreadA: 2
ThreadB: 2
ThreadA: 3
ThreadB: 3
ThreadA: 4
ThreadB: 4

在这个Demo⾥，线程A和线程B⾸先打印出⾃⼰需要的东⻄，然后使 ⽤ notify() ⽅法叫醒另⼀个正在等待的线程，然后⾃⼰使⽤ wait() ⽅法陷⼊等待 并释放 lock 锁。

需要注意的是等待/通知机制使⽤的是使⽤同⼀个对象锁，如果你两个线程使 ⽤的是不同的对象锁，那它们之间是不能⽤等待/通知机制通信的

三、信号量

JDK提供了⼀个类似于“信号量”功能的类 Semaphore 。但本⽂不是要介绍这个类，后⾯会有专⻔的章节介绍 Semaphore， ⽽是介绍⼀种基于 volatile 关键字的⾃⼰实现的信号量通信。

 volitile关键字能够保证内存的可⻅性，如果⽤volitile关键字声明了⼀个变 量，在⼀个线程⾥⾯改变了这个变量的值，那其它线程是⽴⻢可⻅更改后的 值的

⽐如我现在有⼀个需求，我想让线程A输出0，然后线程B输出1，再然后线程A输出 2…以此类推。我应该怎样实现呢？

public class Signal {private static volatile int signal = 0;static class ThreadA implements Runnable {@Overridepublic void run() {while (signal < 5) {if (signal % 2 == 0) {System.out.println("threadA: " + signal);synchronized (this) {signal++;}}}}}static class ThreadB implements Runnable {@Overridepublic void run() {while (signal < 5) {if (signal % 2 == 1) {System.out.println("threadB: " + signal);synchronized (this) {signal = signal + 1;}}}}}public static void main(String[] args) throws InterruptedException {new Thread(new ThreadA()).start();Thread.sleep(1000);new Thread(new ThreadB()).start();}
}

我们可以看到，使⽤了⼀个 volatile 变量 signal 来实现了“信号量”的模型。这⾥ 需要注意的是， volatile 变量需要进⾏原⼦操作。 signal++ 并不是⼀个原⼦操 作，所以我们需要使⽤ synchronized 给它“上锁”。

这种实现⽅式并不⼀定⾼效，本例只是演示信号量

信号量的应⽤场景：

假如在⼀个停⻋场中，⻋位是我们的公共资源，线程就如同⻋辆，⽽看⻔的管理员 就是起的“信号量”的作⽤。 因为在这种场景下，多个线程（超过2个）需要相互合作，我们⽤简单的“锁”和“等 待通知机制”就不那么⽅便了。这个时候就可以⽤到信号量。 其实JDK中提供的很多多线程通信⼯具类都是基于信号量模型的

四、管道

管道是基于“管道流”的通信⽅式。JDK提供了 PipedWriter 、 PipedReader 、 PipedOutputStream 、 PipedInputStream 。其中，前⾯两个是基于字符的，后⾯两 个是基于字节流的。 这⾥的示例代码使⽤的是基于字符的：

public class Pipe {static class ReaderThread implements Runnable {private PipedReader reader;public ReaderThread(PipedReader reader) {this.reader = reader;}@Overridepublic void run() {System.out.println("this is reader");int receive = 0;try {while ((receive = reader.read()) != -1) {System.out.print((char) receive);}} catch (IOException e) {e.printStackTrace();}}}static class WriterThread implements Runnable {private PipedWriter writer;public WriterThread(PipedWriter writer) {this.writer = writer;}@Overridepublic void run() {System.out.println("this is writer");int receive = 0;try {writer.write("test");} catch (IOException e) {e.printStackTrace();} finally {try {writer.close();} catch (IOException e) {e.printStackTrace();}}}}public static void main(String[] args) throws IOException, InterruptedException {PipedWriter writer = new PipedWriter();PipedReader reader = new PipedReader();writer.connect(reader); // 这⾥注意⼀定要连接，才能通信new Thread(new ReaderThread(reader)).start();Thread.sleep(1000);new Thread(new WriterThread(writer)).start();}
}

输出

this is reader
this is writer
test

我们通过线程的构造函数，传⼊了 PipedWrite 和 PipedReader 对象。可以简单分析 ⼀下这个示例代码的执⾏流程：

1. 线程ReaderThread开始执⾏，

2. 线程ReaderThread使⽤管道reader.read()进⼊”阻塞“，

3. 线程WriterThread开始执⾏，

4. 线程WriterThread⽤writer.write("test")往管道写⼊字符串，

5. 线程WriterThread使⽤writer.close()结束管道写⼊，并执⾏完毕，

6. 线程ReaderThread接受到管道输出的字符串并打印，

7. 线程ReaderThread执⾏完毕。

管道通信的应⽤场景： 这个很好理解。使⽤管道多半与I/O流相关。当我们⼀个线程需要先另⼀个线程发 送⼀个信息（⽐如字符串）或者⽂件等等时，就需要使⽤管道通信了。

五、其他通信

以上介绍了⼀些线程间通信的基本原理和⽅法。除此以外，还有⼀些与线程通信相 关的知识点，这⾥⼀并介绍

1、join方法

join()⽅法是Thread类的⼀个实例⽅法。它的作⽤是让当前线程陷⼊“等待”状态，等 join的这个线程执⾏完成后，再继续执⾏当前线程。 有时候，主线程创建并启动了⼦线程，如果⼦线程中需要进⾏⼤量的耗时运算，主 线程往往将早于⼦线程结束之前结束。 如果主线程想等待⼦线程执⾏完毕后，获得⼦线程中的处理完的某个数据，就要⽤ 到join⽅法了。

示例代码：

public class Join {static class ThreadA implements Runnable {@Overridepublic void run() {try {System.out.println("我是⼦线程，我先睡⼀秒");Thread.sleep(1000);System.out.println("我是⼦线程，我睡完了⼀秒");} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new ThreadA());thread.start();thread.join();System.out.println("如果不加join⽅法，我会先被打出来，加了就不⼀样了");}
}

注意join()⽅法有两个重载⽅法，⼀个是join(long)， ⼀个是join(long, int)。 实际上，通过源码你会发现，join()⽅法及其重载⽅法底层都是利⽤了 wait(long)这个⽅法。 对于join(long, int)，通过查看源码(JDK 1.8)发现，底层并没有精确到纳秒， ⽽是对第⼆个参数做了简单的判断和处理。

2、sleep⽅法

sleep⽅法是Thread类的⼀个静态⽅法。它的作⽤是让当前线程睡眠⼀段时间。它 有这样两个⽅法：

• Thread.sleep(long)
• Thread.sleep(long, int)

同样，查看源码(JDK 1.8)发现，第⼆个⽅法貌似只对第⼆个参数做了简单的 处理，没有精确到纳秒。实际上还是调⽤的第⼀个⽅法。

这⾥需要强调⼀下：sleep⽅法是不会释放当前的锁的，⽽wait⽅法会。这也是最 常⻅的⼀个多线程⾯试题。

它们还有这些区别：

• wait可以指定时间，也可以不指定；⽽sleep必须指定时间。
• wait释放cpu资源，同时释放锁；sleep释放cpu资源，但是不释放锁，所以易 死锁。
• wait必须放在同步块或同步⽅法中，⽽sleep可以再任意位置

3、ThreadLocal

ThreadLocal是⼀个本地线程副本变量⼯具类。内部是⼀个弱引⽤的Map来维护，

有些朋友称ThreadLocal为线程本地变量或线程本地存储。严格来说，ThreadLocal 类并不属于多线程间的通信，⽽是让每个线程有⾃⼰”独⽴“的变量，线程之间互不 影响。它为每个线程都创建⼀个副本，每个线程可以访问⾃⼰内部的副本变量。 ThreadLocal类最常⽤的就是set⽅法和get⽅法。示例代码：

public class ThreadLocalDemo {static class ThreadA implements Runnable {private ThreadLocal<String> threadLocal;public ThreadA(ThreadLocal<String> threadLocal) {this.threadLocal = threadLocal;}@Overridepublic void run() {threadLocal.set("A");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("ThreadA输出：" + threadLocal.get());}static class ThreadB implements Runnable {private ThreadLocal<String> threadLocal;public ThreadB(ThreadLocal<String> threadLocal) {this.threadLocal = threadLocal;}@Overridepublic void run() {threadLocal.set("B");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("ThreadB输出：" + threadLocal.get());}}public static void main(String[] args) {ThreadLocal<String> threadLocal = new ThreadLocal<>();new Thread(new ThreadA(threadLocal)).start();new Thread(new ThreadB(threadLocal)).start();}}
}

可以看到，虽然两个线程使⽤的同⼀个ThreadLocal实例（通过构造⽅法传⼊）， 但是它们各⾃可以存取⾃⼰当前线程的⼀个值。 那ThreadLocal有什么作⽤呢？如果只是单纯的想要线程隔离，在每个线程中声明 ⼀个私有变量就好了呀，为什么要使⽤ThreadLocal？

如果开发者希望将类的某个静态变量（user ID或者transaction ID）与线程状态关 联，则可以考虑使⽤ThreadLocal。 最常⻅的ThreadLocal使⽤场景为⽤来解决数据库连接、Session管理等。数据库连 接和Session管理涉及多个复杂对象的初始化和关闭。如果在每个线程中声明⼀些 私有变量来进⾏操作，那这个线程就变得不那么“轻量”了，需要频繁的创建和关闭 连接。

InheritableThreadLocal类与ThreadLocal类稍有不同，Inheritable是继承的意思。 它不仅仅是当前线程可以存取副本值，⽽且它的⼦线程也可以存取这个副本值。

 

关于ThreadLocal、InheritThreadLocal、TransmittableThreadLocal使用详细文章

ThreadLocal、InheritThreadLocal、TransmittableThreadLocal_herithreadlocal