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 {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread A " + i);
            }
        }
    }
 
    static class ThreadB implements Runnable {
        @Override
        public 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 {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread A " + i);
                }
            }
        }
    }
    static class ThreadB implements Runnable {
        @Override
        public 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 {
        @Override
        public 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 {
        @Override
        public 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 {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 0) {
                    System.out.println("threadA: " + signal);
                    synchronized (this) {
                        signal++;
                    }
                }
            }
        }
    }
    static class ThreadB implements Runnable {
        @Override
        public 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;
        }
 
        @Override
        public 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;
        }
 
        @Override
        public 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 {
        @Override
        public 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;
        }
        @Override
        public 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;
            }
            @Override
            public 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

java多线程之线程通信

一、锁与同步

二、等待/通知机制

三、信号量

四、管道

五、其他通信

1、join方法

2、sleep⽅法

3、ThreadLocal

热门文章

最新文章

相关课程

相关电子书

相关实验场景