《Java多线程编程核心技术》学习笔记（二）——多线程间通信

最新推荐文章于 2024-04-24 22:50:14 发布
最新推荐文章于 2024-04-24 22:50:14 发布
阅读量525 收藏
点赞数
分类专栏： web学习 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benhuo931115/article/details/53689846
版权

线程间通信

等待/通知机制

方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入”预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获取该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其他线程竞争重新获得锁，如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException

方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁，如果调用notify()时没有持有适当的锁，也会抛出IllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。

wait使线程停止运行，而notify使停止的线程继续运行

    synchronized(lock){
        System.out.println("开始   wait time="+System.currentTimeMillis());
        lock.wait();
        System.out.println("结束   wait time="+System.currentTimeMillis());
    }

    ...

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

释放锁的情况：

  • 1）执行完同步代码块就会释放对象的锁
  • 2）在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放
  • 3）在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放对象锁，而此线程对象会进入线程等待池中，等待被唤醒

方法wait(long)的使用

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

生产者/消费者模式实现

    //生产者
    public class P{

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

        public void setValue(){
            try{
                synchronized(lock){
                    while(!ValueObject.value.equals("")){
                        System.out.println("生产者"+Thread.currentThread().getName+" WAITING了");
                        lock.wait();
                    }
                    System.out.println("生产者"+Thread.currentThread().getName()+" RUNNABLE了");
                    String value = System.currentTimeMillis()+"_"+System.nanoTime();
                    ValueObject.value = value;
                    lock.notify();
                }
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }

    }

    //消费者
    public class C{

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

        public void getValue(){
            try{
                synchronized(lock){
                    while(ValueObject.value.equals("")){
                        System.out.println("消费者"+Thread.currentThread().getName+" WAITING了");
                        lock.wait();
                    }
                    System.out.println("消费者"+Thread.currentThread().getName()+" RUNNABLE");
                    ValueObject.value = "";
                    lock.notify();
                }
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }

    }

    //线程P
    public class ThreadP extends Thread{

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

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

    }

    //线程C
    public class ThreadC extends Thread{

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

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

    }

    //执行
    public class Run{

        public static void main(String[] args) throws InterruptedException{

            String lock = new String("");
            P p = new P(lock);
            C c = new C(lock);
            ThreadP[] pThread = new ThreadP[2];
            ThreadC[] cThread = new ThreadC[2];
            for(int i = 0;i<2;i++){
                pThread[i] = new ThreadP(p);
                pThread[i].setName("生产者"+(i+1));
                cThread[i] = new ThreadC(c);
                pThread[i].setName("消费者"+(i+1));
                pThread[i].start();
                cThread[i].start();
            }
            Thread.sleep(5000);
            Thread[] threadArray = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
            Thread.currentThread().getThreadGroup().enumerate(threadArray);
            for(int i =0;i<threadArray.length;i++){
                System.out.println(threadArray[i].getName()+""+threadArray[i].getState());
            }

        }

    }

多生产与多消费导致假死：notify唤醒的不是异类而是同类，比如”生产者”唤醒”生产者”或”消费者”唤醒”消费者”，就会导致所有的线程都不能继续运行下去，都呈WAITING状态

解决：用notifyAll()代替notify()

通过管道进行线程间通信：字节流

管道流(pipeStream)是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输出管道中读取数据。从而实现不同线程间的通信

在Java的JDK中提供了4个类来使线程间可以进行通信：

  • 1）PipedInputStream和PipedOutputStream

  • 2）PipedReader和PipedWriter

    //WriteData类
public class WriteData{

    public void writeMethod(PipedOutputStream out){
        try{
            System.out.println("write :");
            for(int i = 0;i<300;i++){
                String outData = ""+(i+1);
                out.write(outData.getBytes());
                System.out.print(outData);
            }
            System.out.println();
            out.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }

}

//ReadData类
public class ReadData{

    public void readMethod(PipedInputStream input){
        try{
            System.out.println("read :");
            byte[] byteArray = new byte[20];
            int readLength = input.read(byteArray);
            while(readLength != -1){
                String newData = new String(byteArray,0,readLength);
                System.out.print(newData);
                readLength = input.read(byteArray);
            }
            System.out.println();
            input.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }

}

//Write线程
public class ThreadWrite extends Thread{

    private WriteData write;
    private PipedOutputStream out;

    public ThreadWrite(WriteData write,PipedOutputStream out){
        super();
        this.write = write;
        this.out = out;
    }

    @Override
    public void run(){
        write.writeMethod(out);
    }

}

//Read线程
public class ThreadRead extends Thread{

    private ReadData read;
    private PipedInputStream input;

    public ThreadRead(ReadData read,PipedInputStream input){
        super();
        this.read = read;
        this.input = input;
    }

    @Override
    public void run(){
        read.readMethod(input);
    }

}

//Run类
public class Run{

    public static void main(String[] args){
        try{
            WriteData writeData = new WriteData();
            ReadData readData = new ReadData();

            PipedInputStream inputStream = new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();

            //inputStream.connect(outputStream);
            outputStream.connnect(inputStream);
            ThreadRead threadRead = new ThreadRead(readData,inputStream);
            threadRead.start();

            Thread.sleep(2000);

            ThreadWrite threadWrite = new THreadWrite(writeData,outputStream);
            threadWrite.start();

        }catch(IOException e){
            e.printStackTrace();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }

}

    使用inputStream.connect(outputStream)或outputStream.connect(inputStream)的作用使两个Stream之间产生通信链接，这样才可以将数据进行输出与输入

    管道中还可以传递字符流，只要将PipedInputStream换成PipedReader，PipedOutputStream换成PipedWriter

多线程join的使用

在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。如果主线程想等到子线程执行完成后再结束，就要用到join()方法，
join()方法的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期的阻塞，等待线程x销毁后再继续执行线程z后面的代码

方法join具有使线程排队运行的作用，有些类似同步的运行效果。join与synchronized的区别是：join在内部使用wait()方法进行等待，而synchronized关键字使用的是”对象监视器”原理做为同步

在join过程中，如果当前线程对象被中断，则当前线程出现异常(join()和interrupt()彼此遇到就会出现异常)

join(long)中的参数是设定等待的时间

join(long)与sleep(long)的区别：
join(long)的功能在内部是使用wait(long)方法来实现的，所以join(long)方法具有释放锁的特点。
而Thread.sleep(long)方法却不释放锁

类ThreadLocal的使用

变量值的共享可以使用public static变量的形式，所有的线程都使用同一个public static变量，如果想实现每一个线程都有自己的共享变量可以使用类ThreadLocal

类ThreadLocal主要解决的就是每个线程绑定自己的值，可以将ThreadLocal类比喻成全局存放数据的盒子，盒子中可以存储每个线程的私有数据

    public class ThreadLocalExt extends ThreadLocal{

        //覆盖initialValue()方法具有初始值
        @Override
        protected Object initialValue(){
            return new Date().getTime();
        }

    }

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

    //线程A
    public 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(InterruptedException e){
                e.printStackTrace();
            }
        }

    }

    //Run类
    public class Run(){

        public static void main(String[] args){
            try{
                for(int i = 0;i<10;i++){
                    System.out.print("   在Main线程中取值="+Tools.t1.get());
                    Thread.sleep(100);
                }
                Thread.sleep(5000);
                ThreadA a = new ThreadA();
                a.start();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }

    }
benhuo931115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程核心技术.zip
09-24
Java多线程编程核心技术和源码
【JAVA多线程】多线程编程核心技术学习资料
03-02
【JAVA多线程】多线程编程核心技术学习资料。学习java多线程学习资料文档。适合初中级java开发人员学习的书籍资料
Java线程之释放锁，释放资源，释放CPU
热门推荐
Java技术
06-17 1万+
多线程中的wait与sleep到底谁释放了锁首先，多线程中会使用到两个延迟的函数，wait和sleep。 wait是Object类中的方法，而sleep是Thread类中的方法。sleep是Thread类中的静态方法。无论是在a线程中调用b的sleep方法，还是b线程中调用a的sleep方法，谁调用，谁睡觉。最主要的是sleep方法调用之后，并没有释放锁。使得线程仍然可以同步控制。sleep不会让
线程的同步
我只是坚持我的兴趣。
10-20 966
线程的同步 原子操作：根据Java规范，对于基本类型的赋值或者返回值操作，是原子操作。但这里的基本数据类型不包括long和double, 因为JVM看到的基本存储单位是32位，而long 和double都要用64位来表示。所以无法在一个时钟周期内完成。 自增操作（++）不是原子操作，因为它涉及到一次读和一次写。 原子操作：由一组相关的操作完成，这些操作可能会操纵与其它的线程共享的资源
JAVA多线程并发编程学习笔记2——线程同步和通信
WellsLau的博客
11-13 273
JAVA并发编程 3. 线程同步 3.1 相关概念 3.1.1 含义 线程同步机制是一套用于协调线程之间的数据访问的机制，用来保证线程安全。 3.1.2 方法 锁 volatile关键字 final, static关键字 相关API，如wait(), sleep(), notify()等 3.2 锁 3.2.1 含义 锁可以理解为对共享数据进行保护的一个许可证，线程在访问共享数据前必须先获得锁，一个锁只能同时被一个线程持有，线程在结束访问之后释放锁。 3.2.2 作用 保障原子性：通过互斥保障原子性
《Java 多线程编程核心技术》学习笔记及总结
http://www.54tianzhisheng.cn/
06-05 1577
第一章 Java 多线程技能 进程和线程的概念及多线程的优点 使用多线程 继承 Thread 类 实现 Runnable 接口 currentThread 方法 isAlive 方法 sleep 方法 getId 方法 停止线程 判断线程是否是停止状态 在沉睡中停止 在停止中沉睡 能停止的线程 暴力停止 暂停线程 suspend 和 resume 方法的使用 yield 方法 线程的优先级 守护
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
作为开发者，我们除了能够熟练使用常用的多线程编程技术外，对于复杂场景的多线程及决方案也要有所了解，例如互相依赖的任务的线程分配，多队列组的应用、死锁场景的分析和优化等。 本课程将详细介绍pthread、...
Java多线程编程核心技术_完整版_java_
09-30
详细介绍了java多线程的原理以及常用多线程编程方法及注意事项。
JAVA多线程编程技术PDF
08-28
JAVA多线程编程技术PDF，是最经典的那个版本，多线程的所有知识点完爆读者
《Java多线程编程核心技术》学习笔记（三）——Lock、Timer、单例模式
benhuo931115的博客
12-19 1317
Lock的使用使用ReentrantLock类在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加灵活调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释
《Java多线程编程核心技术》学习笔记（一）——Java的多线程
benhuo931115的博客
12-15 1108
Java多线程进程：系统进行资源分配和调度的一个独立单位 线程：在进程中独立运行的子任务使用多线程：多线程是异步的线程启动顺序与start()执行顺序无关非线程安全：指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况，进而影响程序的执行流程。解决方法：在run方法前加入synchronized关键字，使多个线程在执行run方法时，以排队的方式进行处理public cl
Struts标签基本知识
benhuo931115的博客
01-12 1049
Struts标签基本知识1.普通标签：控制执行的流程1.1 控制标签：实现分支、循环等流程控制if elseif else append generator iterator merge sort subset 1.2 数据标签：输出后台的数据和完成其他数据访问功能a action bean date debug i18n include param property push set text u
《深入理解Java虚拟机——JVM高级特性与最佳实践》学习笔记——自动内存管理机制
benhuo931115的博客
01-19 745
《深入理解Java虚拟机——JVM高级特性与最佳实践》学习笔记——自动内存管理机制1.概述对于从事C、C++程序开发的开发人员来说，在内存管理领域，既拥有每一个对象的”所有权”，又担负着每一个对象生命开始到终结的维护责任对于Java程序员来说，在虚拟机自动内存管理机制的帮助下，不再需要为每一个new操作去写配对的delete/free代码，不容易出现内存泄漏和内存溢出问题，但也正因为Java程序员把
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 220
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1332
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 469
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1248
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
MSE实现全链路灰度实践
最新发布
云计算、数据库、大数据、深度学习、NLP、Python
04-24 198
待更新。
java的多线程编程中使用队列实现线程间的通信
06-09
是的，Java的多线程编程中通常使用队列来实现线程间的通信。具体而言，一个线程可以将消息或任务放入队列中，而另一个线程则可以从队列中取出这些消息或任务并进行处理。这种方法可以有效地解耦线程之间的关系，使得...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值