【多线程】线程间通信

刺骨的言语ヽ痛彻心扉 2023-07-21 05:54 112阅读 0赞

等待通知机智的实现

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

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

在执行wait()方法后，当前线程释放锁。

如果调用wait()是没有持有适当的锁，则抛出IIegalMonitorStateException,它是RuntimeException的一个子类。

方法notify（）也要在同步方法或同步代码块中调用，即在调用前，线程也必须获得该对象的对象级别锁。

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

需要说明的是，在执行notify（）方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify（）方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态的线程才可以获取该对象的锁。

当第一个获得了该对象锁的wait线程运行完毕后，他会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这对象发出一个notify或notifyall.

用一句话来总结一下wait和notify：

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

以上说法创建测试项目

wait_notify_size5

创建MyList类

  1. public class MyList {
  3.     private static List list = new ArrayList();
  5.     public static void add() {
  6.         list.add("anything");
  7.     }
  9.     public static int size() {
  10.         return list.size();
  11.     }
  12. }

类ThreadA

  1. public class ThreadA extends Thread {
  2.     private Object lock;
  3.     public ThreadA(Object lock){
  4.         super();
  5.         this.lock = lock;
  6.     }
  8.     @Override
  9.     public void run() {
  11.         try {
  12.             synchronized (lock){
  13.                 if(MyList.size() != 5){
  14.                     System.out.println("wait begin"+System.currentTimeMillis());
  15.                     lock.wait();
  16.                     System.out.println("wait end"+ System.currentTimeMillis());
  17.                 }
  18.             }
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  23.     }
  24. }

类ThreadB

  1. public class ThreadB extends Thread {
  2.     private Object lock;
  4.     public ThreadB(Object lock) {
  5.         super();
  6.         this.lock = lock;
  7.     }
  9.     @Override
  10.     public void run() {
  12.         try {
  13.             synchronized (lock) {
  14.                 for (int i = 0; i < 10; i++) {
  15.                     MyList.add();
  16.                     if (MyList.size() == 5) {
  17.                         lock.notify();
  18.                         System.out.println("已发出通知");
  20.                     }
  21.                     System.out.println("添加了" + (i + 1) + "个元素！");
  22.                     Thread.sleep(1000);
  23.                 }
  24.             }
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  29.     }
  30. }

类Run

  1. public class Run {
  3.     public static void main(String[] args) {
  5.         try {
  6.             Object lock = new Object();
  7.             ThreadA a = new ThreadA(lock);
  8.             a.start();
  9.             Thread.sleep(50);
  10.             ThreadB b = new ThreadB(lock);
  11.             b.start();
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

运行结果如下

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70

日志信息 wait end 在最后输出，这也说明notify()方法执行后并不是立即释放锁。

关键字synchronized可以将任何一个Object对象作为同步对象来看待，而java为每个对象都实现了wait()和notify（）方法，它们必须用在被synchronized同步的Object的临界区内。通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。而notify操作可以唤醒一个因调用了wait操作而处于阻塞状态的线程，使其进入就绪状态。被重新唤醒的线程会试图重新获得临界区的控制权，也就是锁，并继续执行临界区内wait之后的代码。

如果发出的notify操作时没有处于阻塞状态中的线程，那么该命令就会被忽略。

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

notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个”线程，并是该线程退出等待队列，进入可运行状态，也就是notify（）方法仅通知“一个”线程。

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

方法notify（）被执行后，不释放锁，必须执行完notify()方法所在的同步代码块synchronized代码块后才释放锁。

当线程呈wait()状态时，调用线程对象的interrupt()方法会出现InterruptedException异常。

方法notify()仅随机唤醒一个线程。

当多次调用notify（）方法时，会随机将等待wait状态的线程进行唤醒。

notifyAll()唤醒所有的线程

wait(long)

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

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

管道流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据。通过使用管道，实现不同线程间的通信，而无需借助于累死临时文件之类的东西。

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

1）PipedInputStream和PipedOutputStream

2)PipedReader和PipedWriter

创建测试项目pipeInputOutPut

  1. 类ReadData
  3. public class ReadData {
  4.     public void readMethod(PipedInputStream input){
  6.         try {
  7.             System.out.println("read :");
  8.             byte[] byteArray = new byte[20];
  10.             int readLength = input.read(byteArray);
  12.             while (readLength != -1){
  13.                 String newData = new String(byteArray, 0, readLength);
  14.                 System.out.println("读取到："+newData);
  15.                 readLength = input.read(byteArray);
  16.             }
  17.             System.out.println();
  18.             input.close();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }

类WriteData

  1. public class WriteData {
  2.     public void writeMethod(PipedOutputStream out){
  3.         try {
  4.             System.out.println("write :");
  5.             for (int i = 0; i < 300; i++) {
  6.                 String outData = ""+(i+1);
  7.                 out.write(outData.getBytes());
  8.                 System.out.println("写入："+outData);
  9.             }
  10.             System.out.println();
  11.             out.close();
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

类ThreadRead

  1. public class ThreadRead extends Thread {
  3.     private ReadData read;
  4.     private PipedInputStream input;
  6.     public ThreadRead(ReadData read, PipedInputStream input) {
  8.         super();
  9.         this.read = read;
  10.         this.input = input;
  11.     }
  13.     @Override
  14.     public void run() {
  15.         read.readMethod(input);
  16.     }
  17. }

类ThreadWrite

  1. public class ThreadWrite extends Thread {
  3.     private WriteData write;
  4.     private PipedOutputStream out;
  6.     public ThreadWrite(WriteData write, PipedOutputStream out){
  7.         super();
  8.         this.write = write;
  9.         this.out = out;
  10.     }
  12.     @Override
  13.     public void run() {
  14.         write.writeMethod(out);
  15.     }
  16. }

类Run

  1. public class Run {
  3.     public static void main(String[] args) {
  5.         try {
  6.             WriteData writeData = new WriteData();
  7.             ReadData readData = new ReadData();
  8.             PipedInputStream inputStream = new PipedInputStream();
  9.             PipedOutputStream outputStream = new PipedOutputStream();
  11.             //使两个Stream之间产生通信链接，这样才可以将数据进行输出与输入
  12.             outputStream.connect(inputStream);
  13.             ThreadRead threadRead = new ThreadRead(readData, inputStream);
  14.             threadRead.start();
  15.             Thread.sleep(2000);
  16.             ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
  17.             threadWrite.start();
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } catch (InterruptedException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24. }

运行结果

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 1

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

创建测试项目

  1. pipeReaderWriter
  3. 类ReadData
  5. public class ReadData {
  7.     public void readMethod(PipedReader input) {
  8.         try {
  9.             System.out.println("read: ");
  10.             char[] byteArray = new char[20];
  11.             int readLength = input.read(byteArray);
  12.             while (readLength != -1) {
  13.                 String newData = new String(byteArray, 0, readLength);
  14.                 System.out.println("读数据："+newData);
  15.                 readLength = input.read(byteArray);
  16.             }
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

类WriteData

  1. public class WriteData {
  3.     public void writeMethod(PipedWriter out) {
  4.         try {
  5.             System.out.println("write: ");
  6.             for (int i = 0; i < 300; i++) {
  7.                 String outData = "" + (i + 1);
  8.                 out.write(outData);
  9.                 System.out.println("写入数据："+outData);
  10.             }
  11.             System.out.println();
  12.             out.close();
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17. }

类ThreadRead

  1. public class ThreadRead extends Thread {
  4.     private ReadData read;
  5.     private PipedReader input;
  7.     public ThreadRead(ReadData read, PipedReader input) {
  8.         super();
  9.         this.read = read;
  10.         this.input = input;
  11.     }
  13.     @Override
  14.     public void run() {
  15.         read.readMethod(input);
  16.     }
  17. }

类ThreadWrite

  1. public class ThreadWrite extends Thread {
  3.     private WriteData write;
  4.     private PipedWriter out;
  6.     public ThreadWrite(WriteData write, PipedWriter out){
  7.         super();
  8.         this.write = write;
  9.         this.out = out;
  10.     }
  12.     @Override
  13.     public void run() {
  14.      write.writeMethod(out);
  15.     }
  16. }

类Run

  1. public class Run {
  2.     public static void main(String[] args) {
  3.         try {
  4.             WriteData writeData = new WriteData();
  5.             ReadData readData = new ReadData();
  6.             PipedReader inputStream = new PipedReader();
  7.             PipedWriter outputStream = new PipedWriter();
  8.             outputStream.connect(inputStream);
  9.             ThreadRead threadRead = new ThreadRead(readData, inputStream);
  10.             threadRead.start();
  11.             Thread.sleep(2000);
  12.             ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
  13.             threadWrite.start();
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  21.     }
  23. }

运行结果

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 2

join（）方法的使用

作用说明：

如果子线程中要进行大量的耗时运算，主线程往往早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join（）方法了。

join()的作用就是等待线程对象销毁。

创建测试项目

  1. joinTest

创建类

  1. MyThread
  3. public class MyThread extends Thread {
  5.     @Override
  6.     public void run() {
  7.         try {
  8.             int secondValue = (int) (Math.random() * 10000);
  9.             System.out.println(secondValue);
  10.             Thread.sleep(secondValue);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }
  15. }

创建类

  1. Test
  3. public class Test {
  4.     public static void main(String[] args) {
  6.         try {
  7.             MyThread threadTest = new MyThread();
  8.             threadTest.start();
  9.             threadTest.join();
  10.             System.out.println("我想当ThreadTest对象执行完毕后我再执行，我做到了");
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }
  15. }

运行结果

2020040315315093.png

结论：

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

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

join(long)与sleep(long)的区别

  • 方法join(long)的功能在内部是使用wait(long)方法来实现的，所以join（long）方法具有释放锁的特点。
  • sleep(long)方法不释放锁

类ThreadLocal的使用

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

类ThreadLocal解决的是变量在不同线程间的隔离性，也就是不同线程拥有自己的值，不同线程中的值可以放入ThreadLocal类中进行保存的。

发表评论

表情：
评论列表 （有 0 条评论，112人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ios 多线程间通信

    一、什么是多线程 一个iOS程序就像一个圆，不断循环，直到将它切断。一个运行着的程序就是一个进程或者叫做一个任务，一个进程至少包含一个线程，线程就是程序的执行流。iOS中

    快来打我*快来打我*/ 0 赞/ 368 阅读

    相关 (三) 多线程间通信

    线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体。使线程间进行通信后,系统之间的交互性会更强大，在大大提高CPU利用率的同时还会对各线程任务在处理的

    ╰半夏微凉°╰半夏微凉°/ 0 赞/ 355 阅读