进程间的通信方法

一、进程通信

（1）管道

a）、无名管道（pipe）：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系；

b）、高级管道（popen）：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式；

c）、有名管道（named pipe）：有名管道也是半双工的通信方式，克服了管道没有名字的限制，同时是它允许无亲缘关系进程间的通信；

（2）信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送 信号给进程本身；Linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该 函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；

（3）信号量（Semaphore）：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段；

（4）消息队列（Message queue）： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点；

（5）共享内存（Shared memory）：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信；

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

二、线程通信

（1）共享内存，同上面所述。这里通过内部类实现线程的共享变量

[java]  view plain  copy

 

1. /** * 通过内部类实现线程的共享变量 * */  
2. public class Innersharethread {       
3.     public static void main(String[] args) {       
4.         Mythread mythread = new Mythread();       
5.         mythread.getThread().start();       
6.         mythread.getThread().start();       
7.         mythread.getThread().start();       
8.         mythread.getThread().start();       
9.     }       
10. }       
11. class Mythread {       
12.     int index = 0;       
13.       
14.     private class InnerThread extends Thread {       
15.         public synchronized void run() {       
16.             while (true) {       
17.                 System.out.println(Thread.currentThread().getName()       
18.                         + "is running and index is " + index++);       
19.             }       
20.         }       
21.     }       
22.       
23.     public Thread getThread() {       
24.         return new InnerThread();       
25.     }       
26. }  

（2）管道。首先建立管道流，并将管道流的输入输出对象进行链接；将管道流加入到生产对象（线程）中；通过管道流引出输入输出流，并在线程中对这些流进行操作；注：管道流的的read的方法是一种阻塞方法；

[java]  view plain  copy

 

1. public class CommunicateWhitPiping {  
2.     public static void main(String[] args) {  
3.         /** 
4.          * 创建管道输出流 
5.          */  
6.         PipedOutputStream pos = new PipedOutputStream();  
7.         /** 
8.          * 创建管道输入流 
9.          */  
10.         PipedInputStream pis = new PipedInputStream();  
11.         try {  
12.             /** 
13.              * 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现 
14.              */  
15.             pos.connect(pis);  
16.         } catch (IOException e) {  
17.             e.printStackTrace();  
18.         }  
19.         /** 
20.          * 创建生产者线程 
21.          */  
22.         Producer p = new Producer(pos);  
23.         /** 
24.          * 创建消费者线程 
25.          */  
26.         Consumer c = new Consumer(pis);  
27.         /** 
28.          * 启动线程 
29.          */  
30.         p.start();  
31.         c.start();  
32.     }  
33. }  
34.   
35. /** 
36.  * 生产者线程(与一个管道输入流相关联) 
37.  *  
38.  */  
39. class Producer extends Thread {  
40.     private PipedOutputStream pos;  
41.   
42.     public Producer(PipedOutputStream pos) {  
43.         this.pos = pos;  
44.     }  
45.   
46.     public void run() {  
47.         int i = 8;  
48.         try {  
49.             pos.write(i);  
50.         } catch (IOException e) {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54. }  
55.   
56. /** 
57.  * 消费者线程(与一个管道输入流相关联) 
58.  *  
59.  */  
60. class Consumer extends Thread {  
61.     private PipedInputStream pis;  
62.   
63.     public Consumer(PipedInputStream pis) {  
64.         this.pis = pis;  
65.     }  
66.   
67.     public void run() {  
68.         try {  
69.             System.out.println(pis.read());  
70.         } catch (IOException e) {  
71.             e.printStackTrace();  
72.         }  
73.     }  
74. }  

（3）调用公共接口，还有如Scala语言中的Actor机制等等