线程间通信的几种方式

淩亂°似流年 2021-09-14 22:58 593阅读 0赞

线程间的通信方式

①同步

这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。

参考示例：

复制代码

  1. public class MyObject {
  3.     synchronized public void methodA() {
  4.         //do something....
  5.     }
  7.     synchronized public void methodB() {
  8.         //do some other thing
  9.     }
  10. }
  12. public class ThreadA extends Thread {
  14.     private MyObject object;
  15. //省略构造方法
  16.     @Override
  17.     public void run() {
  18.         super.run();
  19.         object.methodA();
  20.     }
  21. }
  23. public class ThreadB extends Thread {
  25.     private MyObject object;
  26. //省略构造方法
  27.     @Override
  28.     public void run() {
  29.         super.run();
  30.         object.methodB();
  31.     }
  32. }
  34. public class Run {
  35.     public static void main(String[] args) {
  36.         MyObject object = new MyObject();
  38.         //线程A与线程B 持有的是同一个对象:object
  39.         ThreadA a = new ThreadA(object);
  40.         ThreadB b = new ThreadB(object);
  41.         a.start();
  42.         b.start();
  43.     }
  44. }

复制代码

由于线程A和线程B持有同一个MyObject类的对象object，尽管这两个线程需要调用不同的方法，但是它们是同步执行的，比如：线程B需要等待线程A执行完了methodA()方法之后，它才能执行methodB()方法。这样，线程A和线程B就实现了 通信。

这种方式，本质上就是“共享内存”式的通信。多个线程需要访问同一个共享变量，谁拿到了锁（获得了访问权限），谁就可以执行。

②while轮询的方式

代码如下：

复制代码

  1. 1 import java.util.ArrayList;
  2.  2 import java.util.List;
  3.  3 
  4.  4 public class MyList {
  5.  5 
  6.  6     private List<String> list = new ArrayList<String>();
  7.  7     public void add() {
  8.  8         list.add("elements");
  9.  9     }
  10. 10     public int size() {
  11. 11         return list.size();
  12. 12     }
  13. 13 }
  14. 14 
  15. 15 import mylist.MyList;
  16. 16 
  17. 17 public class ThreadA extends Thread {
  18. 18 
  19. 19     private MyList list;
  20. 20 
  21. 21     public ThreadA(MyList list) {
  22. 22         super();
  23. 23         this.list = list;
  24. 24     }
  25. 25 
  26. 26     @Override
  27. 27     public void run() {
  28. 28         try {
  29. 29             for (int i = 0; i < 10; i++) {
  30. 30                 list.add();
  31. 31                 System.out.println("添加了" + (i + 1) + "个元素");
  32. 32                 Thread.sleep(1000);
  33. 33             }
  34. 34         } catch (InterruptedException e) {
  35. 35             e.printStackTrace();
  36. 36         }
  37. 37     }
  38. 38 }
  39. 39 
  40. 40 import mylist.MyList;
  41. 41 
  42. 42 public class ThreadB extends Thread {
  43. 43 
  44. 44     private MyList list;
  45. 45 
  46. 46     public ThreadB(MyList list) {
  47. 47         super();
  48. 48         this.list = list;
  49. 49     }
  50. 50 
  51. 51     @Override
  52. 52     public void run() {
  53. 53         try {
  54. 54             while (true) {
  55. 55                 if (list.size() == 5) {
  56. 56                     System.out.println("==5, 线程b准备退出了");
  57. 57                     throw new InterruptedException();
  58. 58                 }
  59. 59             }
  60. 60         } catch (InterruptedException e) {
  61. 61             e.printStackTrace();
  62. 62         }
  63. 63     }
  64. 64 }
  65. 65 
  66. 66 import mylist.MyList;
  67. 67 import extthread.ThreadA;
  68. 68 import extthread.ThreadB;
  69. 69 
  70. 70 public class Test {
  71. 71 
  72. 72     public static void main(String[] args) {
  73. 73         MyList service = new MyList();
  74. 74 
  75. 75         ThreadA a = new ThreadA(service);
  76. 76         a.setName("A");
  77. 77         a.start();
  78. 78 
  79. 79         ThreadB b = new ThreadB(service);
  80. 80         b.setName("B");
  81. 81         b.start();
  82. 82     }
  83. 83 }

复制代码

在这种方式下，线程A不断地改变条件，线程ThreadB不停地通过while语句检测这个条件(list.size()==5)是否成立 ，从而实现了线程间的通信。但是这种方式会浪费CPU资源。之所以说它浪费资源，是因为JVM调度器将CPU交给线程B执行时，它没做啥“有用”的工作，只是在不断地测试 某个条件是否成立。就类似于现实生活中，某个人一直看着手机屏幕是否有电话来了，而不是： 在干别的事情，当有电话来时，响铃通知TA电话来了。关于线程的轮询的影响，可参考：JAVA多线程之当一个线程在执行死循环时会影响另外一个线程吗？

这种方式还存在另外一个问题：

轮询的条件的可见性问题，关于内存可见性问题，可参考：JAVA多线程之volatile 与 synchronized 的比较中的第一点“一，volatile关键字的可见性”

线程都是先把变量读取到本地线程栈空间，然后再去再去修改的本地变量。因此，如果线程B每次都在取本地的 条件变量，那么尽管另外一个线程已经改变了轮询的条件，它也察觉不到，这样也会造成死循环。

③wait/notify机制

代码如下：

复制代码

  1. 1 import java.util.ArrayList;
  2.  2 import java.util.List;
  3.  3 
  4.  4 public class MyList {
  5.  5 
  6.  6     private static List<String> list = new ArrayList<String>();
  7.  7 
  8.  8     public static void add() {
  9.  9         list.add("anyString");
  10. 10     }
  11. 11 
  12. 12     public static int size() {
  13. 13         return list.size();
  14. 14     }
  15. 15 }
  16. 16 
  17. 17 
  18. 18 public class ThreadA extends Thread {
  19. 19 
  20. 20     private Object lock;
  21. 21 
  22. 22     public ThreadA(Object lock) {
  23. 23         super();
  24. 24         this.lock = lock;
  25. 25     }
  26. 26 
  27. 27     @Override
  28. 28     public void run() {
  29. 29         try {
  30. 30             synchronized (lock) {
  31. 31                 if (MyList.size() != 5) {
  32. 32                     System.out.println("wait begin "
  33. 33                             + System.currentTimeMillis());
  34. 34                     lock.wait();
  35. 35                     System.out.println("wait end  "
  36. 36                             + System.currentTimeMillis());
  37. 37                 }
  38. 38             }
  39. 39         } catch (InterruptedException e) {
  40. 40             e.printStackTrace();
  41. 41         }
  42. 42     }
  43. 43 }
  44. 44 
  45. 45 
  46. 46 public class ThreadB extends Thread {
  47. 47     private Object lock;
  48. 48 
  49. 49     public ThreadB(Object lock) {
  50. 50         super();
  51. 51         this.lock = lock;
  52. 52     }
  53. 53 
  54. 54     @Override
  55. 55     public void run() {
  56. 56         try {
  57. 57             synchronized (lock) {
  58. 58                 for (int i = 0; i < 10; i++) {
  59. 59                     MyList.add();
  60. 60                     if (MyList.size() == 5) {
  61. 61                         lock.notify();
  62. 62                         System.out.println("已经发出了通知");
  63. 63                     }
  64. 64                     System.out.println("添加了" + (i + 1) + "个元素!");
  65. 65                     Thread.sleep(1000);
  66. 66                 }
  67. 67             }
  68. 68         } catch (InterruptedException e) {
  69. 69             e.printStackTrace();
  70. 70         }
  71. 71     }
  72. 72 }
  73. 73 
  74. 74 public class Run {
  75. 75 
  76. 76     public static void main(String[] args) {
  77. 77 
  78. 78         try {
  79. 79             Object lock = new Object();
  80. 80 
  81. 81             ThreadA a = new ThreadA(lock);
  82. 82             a.start();
  83. 83 
  84. 84             Thread.sleep(50);
  85. 85 
  86. 86             ThreadB b = new ThreadB(lock);
  87. 87             b.start();
  88. 88         } catch (InterruptedException e) {
  89. 89             e.printStackTrace();
  90. 90         }
  91. 91     }
  92. 92 }

复制代码

线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list 的size。

A,B之间如何通信的呢？也就是说，线程A如何知道 list.size() 已经为5了呢？

这里用到了Object类的 wait() 和 notify() 方法。

当条件未满足时(list.size() !=5)，线程A调用wait() 放弃CPU，并进入阻塞状态。—-不像②while轮询那样占用CPU

当条件满足时，线程B调用 notify()通知 线程A，所谓通知线程A，就是唤醒线程A，并让它进入可运行状态。

这种方式的一个好处就是CPU的利用率提高了。

但是也有一些缺点：比如，线程B先执行，一下子添加了5个元素并调用了notify()发送了通知，而此时线程A还执行；当线程A执行并调用wait()时，那它永远就不可能被唤醒了。因为，线程B已经发了通知了，以后不再发通知了。这说明：通知过早，会打乱程序的执行逻辑。

④管道通信就是使用java.io.PipedInputStream 和 java.io.PipedOutputStream进行通信

具体就不介绍了。分布式系统中说的两种通信机制：共享内存机制和消息通信机制。感觉前面的①中的synchronized关键字和②中的while轮询 “属于” 共享内存机制，由于是轮询的条件使用了volatile关键字修饰时，这就表示它们通过判断这个“共享的条件变量“是否改变了，来实现进程间的交流。

而管道通信，更像消息传递机制，也就是说：通过管道，将一个线程中的消息发送给另一个。

关于wait/notify更多内容，可参考：JAVA多线程之wait/notify

java线程间通信：

1：线程上下文

2：共享内存

3：IPC通信

4：套接字（Socket），不同的机器之间进行通信

另外：附注通信内容：

linux常用的进程间的通讯方式
（1）、管道(pipe)：管道可用于具有亲缘关系的进程间的通信，是一种半双工的方式，数据只能单向流动，允许一个进程和另一个与它有共同祖先的进程之间进行通信。
（2）、命名管道(named pipe)：命名管道克服了管道没有名字的限制，同时除了具有管道的功能外（也是半双工），它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
（3）、信号（signal）：信号是比较复杂的通信方式，用于通知接收进程有某种事件发生了，除了进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）。
（4）、消息队列：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺
（5）、共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
（6）、内存映射：内存映射允许任何多个进程间通信，每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。
（7）、信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。

（8）、套接字（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

转自：https://www.cnblogs.com/hapjin/p/5492619.html

发表评论

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

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

相关阅读

    相关 Linux线程间同步的几种方式

    信号量 信号量强调的是线程（或进程）间的同步：“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都在sem\_

    Bertha 。Bertha 。/ 0 赞/ 266 阅读