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 {
        @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


相关文章
|
22小时前
|
缓存 NoSQL Redis
|
1天前
|
Java
Java一分钟之-并发编程:线程间通信(Phaser, CyclicBarrier, Semaphore)
【5月更文挑战第19天】Java并发编程中,Phaser、CyclicBarrier和Semaphore是三种强大的同步工具。Phaser用于阶段性任务协调,支持动态注册;CyclicBarrier允许线程同步执行,适合循环任务;Semaphore控制资源访问线程数,常用于限流和资源池管理。了解其使用场景、常见问题及避免策略,结合代码示例,能有效提升并发程序效率。注意异常处理和资源管理,以防止并发问题。
20 2
|
1天前
|
安全 Java 容器
Java一分钟之-并发编程:线程安全的集合类
【5月更文挑战第19天】Java提供线程安全集合类以解决并发环境中的数据一致性问题。例如,Vector是线程安全但效率低;可以使用Collections.synchronizedXxx将ArrayList或HashMap同步;ConcurrentHashMap是高效线程安全的映射;CopyOnWriteArrayList和CopyOnWriteArraySet适合读多写少场景;LinkedBlockingQueue是生产者-消费者模型中的线程安全队列。注意,过度同步可能影响性能,应尽量减少共享状态并利用并发工具类。
15 2
|
1天前
|
Java 程序员 调度
Java中的多线程编程:基础知识与实践
【5月更文挑战第19天】多线程编程是Java中的一个重要概念,它允许程序员在同一时间执行多个任务。本文将介绍Java多线程的基础知识,包括线程的创建、启动和管理,以及如何通过多线程提高程序的性能和响应性。
|
1天前
|
NoSQL Redis 缓存
【后端面经】【缓存】36|Redis 单线程:为什么 Redis 用单线程而 Memcached 用多线程?
【5月更文挑战第17天】Redis常被称为单线程,但实际上其在处理命令时采用单线程,但在6.0后IO变为多线程。持久化和数据同步等任务由额外线程处理,因此严格来说Redis是多线程的。面试时需理解Redis的IO模型,如epoll和Reactor模式,以及其内存操作带来的高性能。Redis使用epoll进行高效文件描述符管理,实现高性能的网络IO。在讨论Redis与Memcached的线程模型差异时,应强调Redis的单线程模型如何通过内存操作和高效IO实现高性能。
28 7
【后端面经】【缓存】36|Redis 单线程:为什么 Redis 用单线程而 Memcached 用多线程?
|
2天前
|
Java
深入理解Java并发编程:线程池的应用与优化
【5月更文挑战第18天】本文将深入探讨Java并发编程中的重要概念——线程池。我们将了解线程池的基本概念,应用场景,以及如何优化线程池的性能。通过实例分析,我们将看到线程池如何提高系统性能,减少资源消耗,并提高系统的响应速度。
12 5
|
2天前
|
消息中间件 安全 Java
理解Java中的多线程编程
【5月更文挑战第18天】本文介绍了Java中的多线程编程,包括线程和多线程的基本概念。Java通过继承Thread类或实现Runnable接口来创建线程,此外还支持使用线程池(如ExecutorService和Executors)进行更高效的管理。多线程编程需要注意线程安全、性能优化和线程间通信,以避免数据竞争、死锁等问题,并确保程序高效运行。
|
2天前
|
存储 Java
【Java】实现一个简单的线程池
,如果被消耗完了就说明在规定时间内获取不到任务,直接return结束线程。
10 0
|
2天前
|
安全 Java 容器
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第18天】随着多核处理器的普及,并发编程变得越来越重要。Java提供了丰富的并发编程工具,如synchronized关键字、显式锁Lock、原子类、并发容器等。本文将深入探讨Java并发编程的核心概念,包括线程安全、死锁、资源竞争等,并分享一些性能优化的技巧。
|
2天前
|
安全 Java 开发者
Java中的多线程编程:理解与实践
【5月更文挑战第18天】在现代软件开发中,多线程编程是提高程序性能和响应速度的重要手段。Java作为一种广泛使用的编程语言,其内置的多线程支持使得开发者能够轻松地实现并行处理。本文将深入探讨Java多线程的基本概念、实现方式以及常见的并发问题,并通过实例代码演示如何高效地使用多线程技术。通过阅读本文,读者将对Java多线程编程有一个全面的认识,并能够在实际开发中灵活运用。