Java多线程编程核心技术总结——线程间的通信（三）

最新推荐文章于 2022-01-15 00:00:16 发布
最新推荐文章于 2022-01-15 00:00:16 发布
阅读量174 收藏
点赞数
分类专栏： Java-并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zy52002520/article/details/80851961
版权

概论：线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体。线程间的通信就是成为整体的比用方案之一，可以说，是线程间进行通信后，系统之间的交互性会更强大，在大大提高CPU利用率的同时还会使程序员对各线程任务在处理的过程中进行有效的把控与监督。

①等待/通知机制

1.不使用等待/通知机制实现线程间通信

示例代码：

public class MyList {
    private volatile List list = new ArrayList();

    public void add() {
        list.add("kiven");
    }

    public int size() {
        return list.size();
    }
}

class ThreadA extends Thread {
    private MyList list;

    public ThreadA(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                list.add();
                System.out.println("添加了" + (i + 1) + "个元素");
                Thread.sleep(1000);
            }
        } catch (Exception e) {
        }
    }
}

class ThreadB extends Thread {
    private MyList list;

    public ThreadB(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try {
            while (true) {
                if (list.size() == 5) {
                    System.out.println("==5 了，线程b要退出了");
                    throw new InterruptedException();
                }
            }
        } catch (Exception e) {
        }
    }
}

class Test {
    public static void main(String[] args) {
        MyList service = new MyList();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
    }
}

运行结果：虽然连个线程间实现了通信，但有一个弊端就是，线程ThreadB.java不停地通过while语句轮询机制来检测某一个条件，这样会浪费CPU资源。如果轮询的时间间隔很小，更浪费CPU资源；如果轮询的时间间隔很大，有可能会取不到想要得到的数据。所以就需要有一种机制来实现减少CPU的资源浪费，而且还可以实现在多个线程间通信，它就是“wait/nofity”机制。


2.等待/通知机制的实现

示例代码：

public class MyThread1 extends Thread {
    private Object lock;

    public MyThread1(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                System.out.println("开始 wait time=" + System.currentTimeMillis());
                lock.wait();
                System.out.println("结束 wait time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
        }
    }

}

class MyThread2 extends Thread {
    private Object lock;

    public MyThread2(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("开始notify time=" + System.currentTimeMillis());
            lock.notify();
            System.out.println("结束notify time=" + System.currentTimeMillis());
        }
    }
}

class Test {
    public static void main(String[] args) throws Exception {
        Object lock = new Object();
        MyThread1 myThread1 = new MyThread1(lock);
        myThread1.start();
        Thread.sleep(3000);
        MyThread2 myThread2 = new MyThread2(lock);
        myThread2.start();
    }
}

运行结果：3秒后线程nofity通知唤醒。


3.使用wait()与notify()来实现前面size()值等于5的实验

示例代码：

public class MyList {
    private static List list = new ArrayList();

    public static void add() {
        list.add("anyString");
    }

    public static int size() {
        return list.size();
    }
}

class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                if (MyList.size() != 5) {
                    System.out.println("wait begin " + System.currentTimeMillis());
                    lock.wait();
                    System.out.println("wait end " + System.currentTimeMillis());
                }
            }
        } catch (InterruptedException e) {
        }
    }
}

class ThreadB extends Thread {
    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if (MyList.size() == 5) {
                        lock.notify();
                        System.out.println("已发出通知!");
                    }
                    System.out.println("添加了" + (i + 1) + "个元素!");
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
        }
    }
}

class Test {
    public static void main(String[] args) throws Exception {
        Object lock = new Object();
        ThreadA a = new ThreadA(lock);
        a.start();
        Thread.sleep(50);
        ThreadB b = new ThreadB(lock);
        b.start();
    }
}
运行代码：wait end 在最后输出，这样说明nofity()方法执行后并不立即释放锁。


4.当interrupt方法遇到wait方法

示例代码：

public class Service {
    public void testMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin wati");
                lock.wait();
                System.out.println("end wait");
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("出现异常了，因为呈wait状态的线程被interrupt了!");
        }
    }
}

class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

class Test {
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            ThreadA a = new ThreadA(lock);
            a.start();
            Thread.sleep(3000);
            a.interrupt();
        } catch (Exception e) {
        }
    }
}

运行结果：


5.只通知一个线程

示例代码：

public class Service {
    public void testMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin wati() ThreadName=" + Thread.currentThread().getName());
                lock.wait();
                System.out.println("end wait() ThreadName=" + Thread.currentThread().getName());
            }
        } catch (Exception e) {
        }
    }
}

class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

class ThreadB extends Thread {
    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

class ThreadC extends Thread {
    private Object lock;

    public ThreadC(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

class NotifyThread extends Thread {
    private Object lock;

    public NotifyThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            lock.notify();
        }
    }
}

class Test {
    public static void main(String[] args) throws Exception {
        Object lock = new Object();
        ThreadA a = new ThreadA(lock);
        a.start();
        ThreadB b = new ThreadB(lock);
        b.start();
        ThreadC c = new ThreadC(lock);
        c.start();
        Thread.sleep(1000);
        NotifyThread notifyThread = new NotifyThread(lock);
        notifyThread.start();

    }
}

运行结果：方法notify()仅随机唤醒一个线程，使用nofityAll()可以唤醒所有线程


6.方法wait(long)的使用

      --带一个参数的wait(long)方法的功能是等待某一时间内是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒。

②生产者/消费者模式实现

1.一生产与一消费：操作值

示例代码：

public class P {
    private String lock;

    public P(String lock) {
        this.lock = lock;
    }

    public void setValue() {
        try {
            synchronized (lock) {
                if (!ValueObject.value.equals("")) {
                    lock.wait();
                }
                String value = System.currentTimeMillis() + "_" + System.nanoTime();
                System.out.println("set的值是" + value);
                ValueObject.value = value;
                lock.notify();
            }
        } catch (Exception e) {
        }
    }
}

class C {
    private String lock;

    public C(String lock) {
        super();
        this.lock = lock;
    }

    public void getValue() {
        try {
            synchronized (lock) {
                if (ValueObject.value.equals("")) {
                    lock.wait();
                }
                System.out.println("get的值是" + ValueObject.value);
                ValueObject.value = "";
                lock.notify();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ValueObject {
    public static String value = "";

}

class ThreadP extends Thread {
    private P p;

    public ThreadP(P p) {
        super();
        this.p = p;
    }

    @Override
    public void run() {
        while (true) {
            p.setValue();
        }
    }
}

class ThreadC extends Thread {
    private C c;

    public ThreadC(C c) {
        super();
        this.c = c;
    }

    @Override
    public void run() {
        while (true) {
            c.getValue();
        }
    }
}

class Test {
    public static void main(String[] args) {
        String lock = new String("");
        P p = new P(lock);
        C c = new C(lock);
        ThreadP pthread = new ThreadP(p);
        ThreadC cthread = new ThreadC(c);
        pthread.start();
        cthread.start();
    }
}
运行结果：


③方法join的使用

1.引入join铺垫

示例代码:

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
        }
    }
}

class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        //Thread.sleep(?)
        System.out.println("我想当threadTest对象执行完毕后我再执行");
        System.out.println("但上面代码中的sleep()中的值应该写多少呢?");
        System.out.println("答案是:根据不能确定:");
    }
}

运行结果：


2.用join()方法来解决

示例代码：

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
        }
    }
}

class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        thread.join();
        System.out.println("我想threadTest对象执行完毕后我再执行，我做到了");
    }
}

运行结果：


3.方法join()如果和interrupt()方法遇到，则会出现异常。

4.方法join(long)与sleep(long)的区别：join(long)具有释放锁的特点，sleep(long)不释放锁。

④类ThreadLocal的使用

1.验证线程变量的隔离性

示例代码：

public class Tools {
    public static ThreadLocal t1 = new ThreadLocal();
}

class ThreadA extends Thread {

    @Override
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                Tools.t1.set("ThreadA" + (i + 1));
                System.out.println("ThreadA get Value=" + Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (Exception e) {
        }
    }
}

class ThreadB extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                Tools.t1.set("ThreadB" + (i + 1));
                System.out.println("ThreadB get Value=" + Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (Exception e) {
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        ThreadA a = new ThreadA();
        ThreadB b = new ThreadB();
        a.start();
        b.start();
        for (int i = 0; i < 100; i++) {
            Tools.t1.set("Main" + (i + 1));
            System.out.println("Main get Value=" + Tools.t1.get());
            Thread.sleep(200);
        }

    }
}

运行结果：虽然3个线程都向t1对象中set()数据值，但每个线程还是能取出自己的数据。


2.使用InheritableThreadLocal可以在子线程中取得父线程继承下来的值

示例代码：

public class InheritableThreadLocalExt extends InheritableThreadLocal {
    @Override
    protected Object initialValue() {
        return new Date().getTime();
    }

    @Override
    protected Object childValue(Object parentValue) {
        return parentValue + "我在子线程加的~!";
    }
}

class Tools {
    public static InheritableThreadLocalExt t1 = new InheritableThreadLocalExt();
}

class ThreadA extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("在ThreadA线程中取得值=" + Tools.t1.get());
                Thread.sleep(100);
            }
        } catch (Exception e) {
        }
    }
}

class Run {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("   在Main线程中取值=" + Tools.t1.get());
            Thread.sleep(100);
        }
        Thread.sleep(3000);
        ThreadA a = new ThreadA();
        a.start();
    }
}
运行结果：


参考：《Java多线程编程核心技术》--机械工业出版社 高洪岩 著

93_Ryan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
【java并发】传统线程同步通信技术
武哥聊编程
05-29 6928
先看一个问题： 有两个线程，子线程先执行10次，然后主线程执行5次，然后再切换到子线程执行10，再主线程执行5次……如此往返执行50次。 　　看完这个问题，很明显要用到线程间的通信了， 先分析一下思路：首先肯定要有两个线程，然后每个线程中肯定有个50次的循环，因为每个线程都要往返执行任务50次，主线程的任务是执行5次，子线程的任务是执行10次。线程间通信技术主要用到wait()方法和n
多线程核心技术-线程间通信
米勺-Michelle
03-06 332
1.等待&amp;通知（wait&amp;notify）机制：wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到再次被唤醒。notify()：方法可以随机唤醒等待队列中等待同一共享资源的一个线程，并使该线程退出等待队列，进入可运行状态，也就是notify()仅通知一个线程（notifyAll()可以通知同一个共享资源的全部线程）ThreadApublic...
线程之间的相互通信
qq_42473704的博客
08-22 9401
线程之间的相互通信                   在介绍线程相互通信前为大家介绍一下有关线程通信的一些知识           线程的状态（线程的生命周期）        线程的状态 NEW 新建状态，刚刚创建完成还没开启的状态 RUNNABLE 可运行状态，有资格执行，可能在执行中，有可能不是在执行中 BLOCKED 锁阻塞状态，要等待其他线程释放锁对...
多线程-线程之间的通信
天道酬勤
03-23 2598
我们经常说线程之间的通信,线程之间的协作,但是根据他的应用场景其实是很容易搞清楚的; 比如说:生产者-消费者,又比如说队列,等等的Demo,在根据生活场景来说: 去菜市场买水果,你是消费者,菜市场是生产者,你没有钱,哪你就等着有钱再买,菜市场没水果,哪你就等着有水果在卖.这种相互等待的过程,就是线程之间通信的过程,也就是协作的过程,那么从以下两个角度或者更多的角度去解决这个问题,并且说明一些关...
Java多线程学习笔记11之线程间通信
you are sherlocked by me!
10-23 220
详细代码见:github代码地址   本节内容: 1) 等待/通知机制概念 2) 中断和轮询两种基本的方式 3) 等待/通知机制的实现 4) wait()/notify()/wait(long)/notifyAll()文档翻译   线程间通信 线程是操作系统中独立的个体，使线程间进行通信后，系统之间的交互性会更强大，在大大提高 CPU利用率的同时还会使程序员对各线程任务在处理...
smoker_java多线程_
09-29
总之，Java多线程编程是构建高效并发应用的基础，涵盖了许多概念和技术，如线程的创建与管理、同步机制、线程安全的数据访问以及线程间通信。理解并熟练掌握这些知识点对于任何Java开发者来说都是至关重要的。
Java练手小项目——多线程聊天室.zip
01-14
【Java练手小项目——多线程...通过这个“Java练手小项目——多线程聊天室”，你可以深入了解Java多线程的原理和实践，同时学习到网络编程和并发集合的运用，这对于提升你的Java编程技能和解决实际问题的能力大有裨益。
基于java swing的多线程电梯调度模拟
05-12
总的来说，这个项目涉及到Java多线程编程、GUI设计、对象间的通信以及线程同步等多个核心概念，是学习和实践Java并发编程的好例子。通过理解和分析这个项目，开发者不仅可以深入理解Java的并发机制，还能掌握如何在...
java并发（二）：深入分析volatile实现原理
weixin_34356310的博客
10-29 90
volatile的原理实现可以看这篇文章，真的是从硬件层面上说明了volatile怎样保证可见性 下面这个实例，如果没有设置成volatile关键字，那么线程读的isRunning永远都是自己私有内存中的，线程将会一直在while循环中 public class RunThread exte...
【Android开发】线程间通讯机制（提高篇）——深入浅出实现原理
q376420785的专栏
05-04 2805
前言： 这一篇博文主要是和大家讲解一下线程间通讯机制的内部实现原理，即Handler、Message、MessageQueue、Looper、HandlerThread、AsyncTask类的实现以及之间的关系。如果还没有接触过Handler+Message+Runnable、HandlerThread、AsyncTask的朋友可以先看看基础篇： 【Android开发】线程间通讯机制（
线程间通信的几种方式
pengzhisen123的博客
03-06 4万+
线程间的通信方式①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。参考示例：public class MyObject { synchronized public void methodA() { //do something.... } synchronized public void methodB() { ...
线程间通信的几种实现方式
热门推荐
InterfaceJ的博客
01-13 18万+
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素&amp;quot;abc&amp;quot;字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用 volatile 关键字 基于 volatile...
线程之间的通讯
prisoneradvance的博客
01-15 2207
线程之间的通讯： 多线程的执行顺序是由cpu决定的，但是有时候需要线程按照预期的顺序执行，就需要线程之间的通讯 线程通讯的方式有很多种： 1. 休眠唤醒： Object: wait() : 导致当前线程等待 notify() : 唤醒正在等待对象监视器的单个线程。 (唤醒当前线程) notifyAll() : 唤醒正在等待对象监视器的所有线程。（唤醒现在的所有线程） Object休眠唤醒必须与synchronized搭配用，wait()必须由notify()来唤醒 Condition: await(
基于Springboot和Vue的数码论坛系统设计与实现-源码 数码论坛系统设计与实现代码（高分毕设）
最新发布
07-24
数码论坛系统设计与实现-源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
java程序设计—JAVA局域网飞鸽传书软件设计与实现(源代码+论文)43.rar
07-24
java程序设计，可供正在学习的同学研究参考。
年终总结汇报PPT模板(20)三套材料.pptx
07-24
年终总结汇报PPT模板(20)三套材料.pptx
ListView侧边A-Z快速定位导航.zip
07-24
ListView侧边A-Z快速定位导航
Java多线程编程实战指南
此外，书中还涵盖了线程同步与通信机制，如`synchronized`关键字、wait()和notify()方法，以及高级特性如`ExecutorService`和`Future`接口，这些都是Java多线程编程中不可或缺的部分。书中可能还会讨论线程安全问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值