线程间的通信

最新推荐文章于 2021-08-08 17:15:14 发布
最新推荐文章于 2021-08-08 17:15:14 发布
阅读量123 收藏
点赞数
分类专栏： 多线程 文章标签： java wait notify
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012133048/article/details/81708516
版权

所谓线程间的通信，无非就是线程之间相互协作，互相影响，数据交互。

 

1、不使用wait和notify

两个线程在不使用wait 和 notify的前提下，也能通过sleep和while来实现相互影响。两个线程对同一个变量做操作，并循环监控这个变量。

 

 

2、wait()和notify()

Wait()

方法wait() 的作用是使当前执行代码的线程进程等待，wait()是Object类的方法，该方法用来将当前线程置入“预执行队列”，并在wait()所在的代码行处停止执行，知道接到通知或者被中断为止。

在调用前线程必须获得该对象的对象级的锁，即只能在同步方法或者同步块中调用wait()方法。

执行wait后，当前线程释放锁，在从wait返回前，该线程与其他线程竞争重新获得锁。如果调用wait时没有适当的锁，则抛出异常， 因此不需要用try-catch语句进行异常捕获。

 

notify()

该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。

在执行notify时，当前线程不会马上释放锁，wait的线程也不能马上得到锁，需要等notify的线程执行完，也就是退出synchronized代码块后，才会释放锁。

notify在调用前线程必须获得该对象的对象级的锁，即只能在同步方法或者同步块中调用。

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

示例代码：

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) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
}





public class MyThread2 extends Thread {

   private Object lock;



   public MyThread2(Object lock) {

      super();

      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());

      }

   }

}


import extthread.MyThread1;

import extthread.MyThread2;



public class Test {

   public static void main(String[] args) {

      try {

         Object lock = new Object();



         MyThread1 t1 = new MyThread1(lock);

         t1.start();



         Thread.sleep(3000);



         MyThread2 t2 = new MyThread2(lock);

         t2.start();



      } catch (InterruptedException e) {

         e.printStackTrace();

      }

   }

}
 

 

wait 方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒。

 

notify 方法可以随机唤醒等待队列中等待同一共享资源的一个线程，并使该线程退出等待推列，进入运行状态，也就是说notify只通知一个线程，而被通知的线程是随机的。

 

notifyAll()  可以使所有正在等待队列中等待同一共享资源的全部线程，从等待状态退出，进入运行状态。此时，优先级最高的那个线程最先执行，也可能是随即执行，这要取决于JVM虚拟机的实现。

 

 

锁释放的情况：1、执行完同步代码块和方法，就会释放对象锁。

                              2、 实行同步代码块的过程中，遇到异常导致线程终止，锁也会被释放。

3、在执行同步代码块中，执行了wait方法，就会释放锁，该线程也很贵进入线程等待池，等待被唤醒。

 

 

3、Wait(long)和通知过早

wait(long) 等待某一段时间是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒。

 

通知过早：nodify在wait之前运行，wait永远不能被唤醒。

示例代码：

 

package test;



public class MyRun {



   private String lock = new String("");

   private boolean isFirstRunB = false;



   private Runnable runnableA = new Runnable() {

      @Override

      public void run() {

         try {

            synchronized (lock) {

               while (isFirstRunB == false) {

                  System.out.println("begin wait");

                  lock.wait();

                  System.out.println("end wait");

               }

            }

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      }

   };



   private Runnable runnableB = new Runnable() {

      @Override

      public void run() {

         synchronized (lock) {

            System.out.println("begin notify");

            lock.notify();

            System.out.println("end notify");

            isFirstRunB = true;



         }

      }

   };



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



      MyRun run = new MyRun();



      Thread a = new Thread(run.runnableA);

      a.start();



      Thread.sleep(100);



      Thread b = new Thread(run.runnableB);

      b.start();



   }



}

 

 

4、管道通信

管道流是一种特殊的流，用于在不同线程之间传送数据。一个线程发送数据到输出管道，另一个线程中管道中读取数据。通过管道，实现不同线程减的通信。

  1. PipedInputStream和PipedOutputStream   字节流
  2. PipedReader和PipedWriter              字符流

 

  1. 字节流示例代码：

 

import java.io.PipedInputStream;



import service.ReadData;



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);

   }

}




import java.io.PipedOutputStream;



import service.WriteData;



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);

   }



}




import java.io.IOException;

import java.io.PipedInputStream;



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();

      }

   }

}




import java.io.IOException;

import java.io.PipedOutputStream;



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();

      }

   }

}




    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.connect(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();

      }



   }



}

 

 

  1. 字符流示例代码：

 

import java.io.PipedReader;



import service.ReadData;



public class ThreadRead extends Thread {



   private ReadData read;

   private PipedReader input;



   public ThreadRead(ReadData read, PipedReader input) {

      super();

      this.read = read;

      this.input = input;

   }



   @Override

   public void run() {

      read.readMethod(input);

   }

}




import java.io.PipedWriter;



import service.WriteData;



public class ThreadWrite extends Thread {



   private WriteData write;

   private PipedWriter out;



   public ThreadWrite(WriteData write, PipedWriter out) {

      super();

      this.write = write;

      this.out = out;

   }



   @Override

   public void run() {

      write.writeMethod(out);

   }



}




public class ReadData {



   public void readMethod(PipedReader input) {

      try {

         System.out.println("read  :");

         char[] byteArray = new char[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();

      }

   }

}




import java.io.IOException;

import java.io.PipedWriter;



public class WriteData {



   public void writeMethod(PipedWriter out) {

      try {

         System.out.println("write :");

         for (int i = 0; i < 300; i++) {

            String outData = "" + (i + 1);

            out.write(outData);

            System.out.print(outData);

         }

         System.out.println();

         out.close();

      } catch (IOException e) {

         e.printStackTrace();

      }

   }

}




import extthread.ThreadRead;

import extthread.ThreadWrite;

import service.ReadData;

import service.WriteData;



import java.io.IOException;

import java.io.PipedReader;

import java.io.PipedWriter;



public class Run {



   public static void main(String[] args) {



      try {

         WriteData writeData = new WriteData();

         ReadData readData = new ReadData();



         PipedReader pipedReader = new PipedReader();

         PipedWriter pipedWriter = new PipedWriter();



         // inputStream.connect(outputStream);

         pipedWriter.connect(pipedReader);



         ThreadRead threadRead = new ThreadRead(readData, pipedReader);

         threadRead.start();



         Thread.sleep(2000);



         ThreadWrite threadWrite = new ThreadWrite(writeData, pipedWriter);

         threadWrite.start();



      } catch (IOException e) {

         e.printStackTrace();

      } catch (InterruptedException e) {

         e.printStackTrace();

      }



   }



}

 

 

运行结果：

 

加油妹妹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程之间的通信
qq_45644339的博客
11-28 1722
参考此博客 一、为什么要线程通信？ 1. 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。 2.当然如果我们没有使用线程通信来使用多线程共同操作同一份数据的话，虽然可以实现，但是在很大程度会造成多线程之间对同一共享变量的争夺，那样的话势必为造成很多错误和损失！ 3.所以，我们才引出了线程之间的通信，多线程之间的通信能够避免对同一共享变量的争夺。 二
线程间通信
二月初二
08-22 143
在日常开发中，多线程之间通常会进行相互协作完成任务。为了支持线程间通信，JDK提供了很多很有趣的方法，其中很普遍的就是等待/通知机制。JDK中使用等待wait()方法和通知notify()/notifyAll()实现，这两个方法不是线程内部所有，而是属于Object。 等待/通知机制—第一种方式: public final void wait() throws InterruptedExcep...
MFC线程间通信
04-05
然而，当一个应用程序中有多个线程运行时，它们可能需要共享数据或协调工作，这就涉及到线程间通信（Inter-Thread Communication，简称ITC）。MFC（Microsoft Foundation Classes）库，作为Windows平台上C++开发的...
线程间通信的定义及全局变量的方法
07-21
本文将重点探讨线程间的通信方式，特别是通过全局变量进行线程间通信的方法以及为了解决数据竞争问题而引入的同步和互斥机制。 首先，线程间通信指的是在同一个进程中的多个线程之间交换信息或数据的过程。由于线程...
Java通过wait()和notifyAll()方法实现线程间通信
08-30
Java提供了一套基于对象监视器机制的线程通信方式，其中包括`wait()`、`notify()`和`notifyAll()`方法。这些方法都是在`java.lang.Object`类中定义的，因此所有Java对象都具备这些功能。本篇将详细介绍如何使用`wait...
Python如何实现线程间通信
01-19
你的程序中有多个线程，你需要在这些线程之间安全地交换信息或数据 解决方案 从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程通过使用...
关于Java线程间通信-回调.docx
最新发布
09-26
在Java编程中，线程间通信（Inter-Thread Communication，简称ITC）是并发编程中的一个重要概念，它涉及...理解并熟练掌握回调以及其他线程通信机制是Java并发编程的关键，这对于开发高效、稳定的多线程应用至关重要。
线程间的通讯
weixin_46060794的博客
08-08 2864
一.为什么需要线程通讯 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程间的通讯定义：多个线程在操作同一份数据时，互相告知自己的状态，避免对同一共享变量的争夺。 二.线程间的通讯方式 线程通讯的方式主要可以分为三种方式，共享内存、消息传递和管道流。 1.共享内存 （1）...
线程的生命周期
qq_40807366的博客
12-17 160
新建： new 关键字创建了一个线程之后，该线程就处于新建状态 JVM为线程分配内存，初始化成员变量 就绪： 当线程对象调用了start() 方法之后，该线程处于就绪状态 JVM为线程创建方法栈帧和程序计数器，等待线程调用器调用 运行： 就绪状态的线程获得CPU资源，开始运行run() 方法，该线程进入运行状态 阻塞： 当发生如下情况时，线程将会进入阻塞状态 线程调用sleep() ...
Android Handler与线程间通信ITC深度解析
"深入理解Android Handler机制以及线程间通信ITC" Android Handler机制是Android系统中用于处理线程间通信的重要工具，尤其是对于UI线程和其他工作线程之间的协调。在Android应用开发中，由于主线程（UI线程）不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值