Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）

已于 2022-02-28 15:35:25 修改
阅读量593 收藏 6
点赞数 1
分类专栏： Java基础 文章标签： java 开发语言 后端
于 2022-02-28 15:16:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangdawei_/article/details/123167436
版权

java多线程入门篇 （三）


java多线程入门篇（一）进程线程基本概念和入门类与接口
Java多线程入门篇（二）线程组线程优先级和线程状态

  在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以

锁与同步

  在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放锁后其它线程才能获得锁。
  同步就是让多个线程按照一定的顺序执行。而锁就是用于实现这个功能。
接下来我们看一个不加锁的程序：

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

一部分结果：

线程A9
线程A10
线程B0
线程A11
线程B1
线程A12
线程B2
线程A13

  从上面可以看出两个线程是各自独立工作的，输出自己的打印值。如果重新运行每次的结果都会不一样。
  接下来一个新的需求：希望A先执行完再执行B，那应该怎么办呢？最简单的方式就是使用一个“对象锁”。

实例代码：

public class Synchroniz1 {
    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("线程A"+i);
                }
            }
        }
    }
    static class ThreadB implements Runnable{
        @Override
        public void run(){
            synchronized (lock){
                for (int i =0;i<100;i++){
                    System.out.println("线程B"+i);
                }
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new ThreadA()).start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new ThreadB()).start();

    }
}

部分结果：

线程A96
线程A97
线程A98
线程A99
线程B0
线程B1
线程B2

这里声明了一个名字为lock的对象锁。我们在ThreadA和ThreadB中需要同步的代码块里，都是用synchronized关键字加上了同一个对象锁lock。这样同一时间就只有一个线程可以持有一个锁。

等待/通知机制

  上面一种基于”锁“的方式，线程需要不断地去尝试获得锁，如果失败了，再继续尝试。这可能会消耗服务器资源，而等待/通知机制是另一种方式。
  Java的等待/通知机制是基于Object类的wait()方法和notify()，notifyAll()方法实现的。（notify()方法随机叫醒一个正在等待的线程，notifyAll()叫醒所有正在等待的线程。）
  我们知道一个锁同一时刻只能被一个线程持有，如果线程A持有了锁lock并开始执行，它可以调用lock.wait()让自己进入等待状态，此时lock锁是被释放了的。
  然后线程B获得了锁并执行，然后调用notify()唤醒之前持有锁的线程。
注意：唤醒不代表运行，不代表获得锁，还是需要等当前持有锁的线程释放锁之后，其它线程才可以去竞争获得锁。

代码实现：

public class Synchroniz2 {
    private static Object lock = new Object();
    static class ThreadA implements Runnable{
        @Override
        public void run(){
            synchronized (lock){
                for (int i = 0;i<5;i++){
                    System.out.println("ThreadA"+i);
                    try {
                        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++){
                    System.out.println("ThreadB"+i);
                    try {
                        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();
    }
}

ThreadA0
ThreadB0
ThreadA1
ThreadB1
ThreadA2
ThreadB2
ThreadA3
ThreadB3
…

  在上面的例子中，线程A,B都是先打印出自己需要打印的东西，然后唤醒另一个线程，自己再进入等待并释放锁。所以呈现的就是A,B线程交叉打印。
注意：等待/通知机制需要线程使用同一个对象锁，如果两个线程使用的是不同的对象锁，那他们是不可以使用等待/通知机制的。

信号量：

信号量 (Semaphore)，有时被称为信号灯，是在 多线程 环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被 并发 调用。 在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。

  jdk提供了类似与”信号量“功能的类：Semaphore。不过接下来我要介绍的是基于volatile关键字自己实现信号量通信的方式。

volatile关键字能够保证内存可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其他线程是立马可见更改之后的值的。

需求：我希望线程A输出0，线程B输出1，线程A输出2，线程B输出3，一次类推，改如何做？

实例代码：

public class SemaphoreDemo {
    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++;
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        new Thread(new ThreadB()).start();
    }
}

ThreadA0
ThreadB1
ThreadA2
ThreadB3
ThreadA4
ThreadB5

通过上面的代码我们使用volatile关键字实现了信号量模型。
注意：volatile变量需要进行原子操作，signal++并不是原子操作所以我们需要使用synchronized给他上锁。

管道：

管道是基于”管道流“的通信方式，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

简单分析执行流程：
1：线程ReaderThread开始执行，
2：线程ReaderThread使用管道reader.read()进入阻塞
3：线程WriterThread开始执行
4：线程WriterThread执行writer.write(“test”),往管道写入字符串
5：线程WriterThread执行结束
6：线程ReaderThread读取管道输入的字符串并打印
7：线程ReaderThread执行结束。

其它通信相关

join方法

  join()方法是Thread类的一个实例方法，作用是让当前线程陷入等待状态。等待join的线程执行完成再继续执行。比如：在主线程中要执行一个子线程，此子线程耗费的时间比较久，如果正常执行会在主线程完成之后完成，此时要是希望子线程先完成则可以在主线程中使用"子线程.join()",使主线程等待子线程完成之后再继续执行。

实例代码：

public class Join {
    static class ThreadA implements Runnable{
        @Override
        public void run(){
            System.out.println("我是子线程，我先等一会");
            try {
                Thread.sleep(1000);
                System.out.println("ok了");
            } 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()管用了，不然应该我先说话");
        }
    }
}

我是子线程，我先等一会
ok了
如果我前面有人说话就代表使用join()管用了，不然应该我先说话

sleep方法

  sleep()是Thread类的一个静态方法，是让当前线程睡一会。
方法有：Thread.sleep(long)，Thread.sleep(long,int)
注意：sleep方法是不会释放当前的锁的。而wait方法会。这也是常见的多线程的面试题。还有就是wait既可以指定时间也可以不指定时间，而sleep必须指定时间。

ThreadLocal类

  它是一个本地线程副本变量工具类，内部是一个弱引用的Map来维护。它是让每个线程有自己独立的变量，线程之间互不影响。
  如果开发者希望将类的某个静态变量与线程状态关联，则可以使用ThreadLocal。常见的使用场景为用来解决数据库连接，Session管理等。

InheritableThreadLocal

  它不仅仅是当前线程可以存取副本值，而且它的子线程也可以存取这个副本值。

机智小袁
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解JAVA多线程之线程间的通信方式
09-02
下面小编就为大家带来一篇深入理解JAVA多线程之线程间的通信方式。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java多线程-线程间的通信
最新发布
02-02
Java多线程--线程间的通信
详解java中的互斥锁信号量和多线程等待机制
08-29
主要介绍了Java编程中的互斥锁,信号量和多线程等待机制实例详解，简单介绍了互斥锁和信号量的区别，需要的朋友可以了解下。
Java编程线程间通信与信号量代码示例
08-28
主要介绍了Java编程线程间通信与信号量代码示例，具有一定借鉴价值，需要的朋友可以参考下。
java多线程编程之管道通信详解
08-29
主要为大家详细介绍了java多线程编程之线程间的通信，探讨使用管道进行通信，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现信号量机制(生产者消费者问题)的三种方式
做兴趣使然的Hero
06-22 1899
一、什么是信号量机制        信号量(Semaphore)，是在程序在多线程环境下使用的一种措施或方案，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量semaphore，然后将等待操作以及释放操作分别放置在每个关键代码段的首末端。确认这
JAVA-信号量
CodeEggs的博客
03-29 2234
信号量： 信号量一般都有以下几个变量： count：记录可以使用的资源数 wait_list：等待信号量的队列 获取信号量需要判断count是否大于零，即if( count > 0 ) 若count > 0，表示可以获取该信号量，意味着获取资源成功，无须睡眠进程 若count == 0，表示不可以获取该信号量，需要进入等待队列中，此时等待队列长度为0，无进程等待 若count < 0，表示不可以获取该信号量，且有Math.abs(count)个进程在等待队列等待资源. ..
Java多线程同步锁、Lock锁和等待唤醒机制及代码演示
weixin_43860634的博客
10-05 352
Java多线程同步锁、lock锁和等待唤醒机制及代码演示
Java锁迭代之Lock锁
weixin_56961284的博客
11-27 643
lock接口的实现类，ReentrantReadWriteLock和ReentrantLock
使用Lock锁实现等待唤醒机制
at10090的博客
02-01 1240
在使用Lock进行解决线程同步问题时,会存在使用Object的wait()和sleep()方法异常的问题. 而jdk也提供了Condition对应于Objcet的wait(),notify()和notifyAll()方法提供了await(),siganl()和signalAll()方法. Condition实例实质上是需要绑定到一个锁上.所以需要为Lock实例获得Condition实例,需要使用......
Java中的信号量（Semaphore）机制详解
赵先森
12-05 924
信号量（Semaphore）是一种用于控制多个线程对共享资源的访问的同步工具类。它维护了一个许可集，许可集的大小决定了同时访问共享资源的线程数量。当一个线程需要访问共享资源时，首先需要获取一个许可；当线程访问完共享资源后，需要释放许可。通过这种方式，信号量可以有效地控制对共享资源的访问，避免因资源竞争而导致的问题。
java 等待锁_Java——线程锁，死锁，等待唤醒机制
weixin_39860975的博客
02-21 654
一、线程锁线程安全问题其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。由于线程休眠的特性，从哪休眠就从哪继续执行(一个线程的事情还没干完就被其他线程挤下去了)，回来继续干就会导致操作的全局变量或静态变量出现问题。为了解决这个问...
详解Java信号量-Semaphore
BASK2311的博客
01-13 895
基本概念：Semaphore是一种基于计数的同步工具，用于控制同时访问特定资源的线程数量。原理理解：Semaphore的实现依赖于AQS（AbstractQueuedSynchronizer），提供了一种机制来管理和控制线程的访问。实际应用：从资源池管理到限流控制，Semaphore在多种场景中都非常有用。高级特性：包括公平性和非公平性的选择，以及对线程中断的响应。问题解决：面对资源耗尽和性能问题，咱们学习了如何妥善处理Semaphore带来的挑战。与其他工具结合。
java信号量_JAVA多线程--信号量(Semaphore)
weixin_42117037的博客
02-12 1429
简介信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对...
锁等待超时
BushRo
12-20 1564
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction (errno: 11 "Resource temporarily unavailable rx_state状态为RUNNING就表示这个事物还在运行中，没有提交。LOCK_WAIT就是被阻塞了，需要等前面RUNNING的提交了才能到自己这边运行。
Java中常见的锁策略
weixin_46429649的博客
06-21 459
1.悲观锁和乐观锁：处理所冲突的态度（原因）2.重量级锁和轻量级锁：处理所冲突的结果3.挂起等待锁和自旋锁：4.读写锁和普通互斥锁：5.公平锁和非公平锁6.可重入锁和不可重入锁synchronized总结synchronized中的锁优化机制 1.锁膨胀/锁升级2.锁粗化3.锁消除ReentrantLock可重入锁 ReentrantLock和synchronized的区别Semaphore信号量 CountDownLatch终点线 CopyOnWriteArrayList写时拷贝...
java 线程 阻塞 等待,线程被阻塞等待信号
weixin_39608394的博客
03-14 109
在我的应用程序中，我尝试捕获SIGUSR1的特定信号，我编写了下面的代码来执行此问题，其中应用程序将为“init_signal_catcher”创建一个线程 .问题是当我运行代码时，程序会永远进入睡眠状态，即使它是SIGUSR1也不会响应任何信号 .那么请你告诉我下面代码中的问题是什么？Note: 以下内容可以直接运行而无需创建线程，只需将函数名称init_signal_catcher替换为mai...
【java】使用线程之间的通讯方式实现生产者和消费者 wait、notify、await、signal 消息通知机制
九师兄
06-03 699
转载：一篇文章，让你彻底弄懂生产者–消费者问题.md生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。但是，这个共享数据区域中应该
java如何让线程等待,如何让Java线程等待另一个线程的输出？
weixin_29595517的博客
02-16 91
I'm making a Java application with an application-logic-thread and a database-access-thread.Both of them persist for the entire lifetime of the application and both need to be running at the same time...
Java 多线程信号量的作用
06-08
在 Java 中，Semaphore 是一个非常重要的多线程同步工具，它可以用于控制并发线程的数量。Semaphore 可以控制同时访问某个资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。 Semaphore 主要有两个作用： 1. 限流：Semaphore 可以限制同时访问某个资源的线程数量，从而达到限流的目的。 2. 控制并发：Semaphore 可以控制并发线程的数量，当线程数量达到 Semaphore 的上限时，其他线程必须等待，直到有线程释放 Semaphore。 在 Java 中，Semaphore 的使用非常灵活，可以根据不同的业务场景进行调整，比如可以设置 Semaphore 的初始值、可以设置 Semaphore 的等待时间等等。Semaphore 是 Java 多线程编程中非常重要的一个类，它可以帮助我们更好地管理线程，提高程序的并发性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值