管道通信（PipedInputStream和PipedOutputStream）与进程通信中的write（）和notify（）的Synchronized同步有什么区别？你在管理机制相同吗？

PipedInputStream和PipedOutputStream 两个管道流主要用来实现线程间通讯的,Synchronized关键字用来解决线程同步的,wait()和notify()是线程对象的两个方法,Synchronized、wait()和notify()一起使用可以很好的解决多线程资源同步问题。所以说两者的作用不同，线程间要通讯不一定要实现线程同步，反过来线程间要同步，线程间也不一定非要通讯。

楼主说的是不是管道通信中线程的问题。
管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。
主要分为一下步骤：

首先建立管道流，并将管道流的输入输出对象进行链接；

将管道流加入到生产对象（线程）中；

通过管道流引出输入输出流，并在线程中对这些流进行操作；

注：管道流的的read的方法是一种阻塞方法；



public class CommunicateWhitPiping {
    public static void main(String[] args) {
        /**
         * 创建管道输出流
         */
        PipedOutputStream pos = new PipedOutputStream();
        /**
         * 创建管道输入流
         */
        PipedInputStream pis = new PipedInputStream();
        try {
            /**
             * 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现
             */
            pos.connect(pis);
        } catch (IOException e) {
            e.printStackTrace();
        }
        /**
         * 创建生产者线程
         */
        Producer p = new Producer(pos);
        /**
         * 创建消费者线程
         */
        Consumer c = new Consumer(pis);
        /**
         * 启动线程
         */
        p.start();
        c.start();
    }
}

/**
* 生产者线程(与一个管道输入流相关联)
*
*/
class Producer extends Thread {
    private PipedOutputStream pos;

    public Producer(PipedOutputStream pos) {
        this.pos = pos;
    }

    public void run() {
        int i = 8;
        try {
            pos.write(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
* 消费者线程(与一个管道输入流相关联)
*
*/
class Consumer extends Thread {
    private PipedInputStream pis;

    public Consumer(PipedInputStream pis) {
        this.pis = pis;
    }

    public void run() {
        try {
            System.out.println(pis.read());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
希望对楼主有帮助

PipedInputStream与PipedOutputStream类用于在应用程序中的创建管道通信。管道通信即发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信。·使用PipedInputStream与PipedOutputStream类编写两个线程间进行通信的程序。

1. import java.io.IOException;
   
2. import java.io.PipedInputStream;
   
3. import java.io.PipedOutputStream;
   
4. 
   
5. class Sender extends Thread{
   
6. PipedOutputStream out = new PipedOutputStream();
   
7. PipedOutputStream getPipedOutputStream(){
   
8. return out;
   
9. }
   
10. public void run(){
    
11. try {
    
12. out.write(new String("hello baby!").getBytes());
    
13. out.close();
    
14. } catch (IOException e) {
    
15. // TODO Auto-generated catch block
    
16. e.printStackTrace();
    
17. }
    
18. }
    
19. }
    
20. 
    
21. class Receiver extends Thread{
    
22. PipedInputStream in = new PipedInputStream ();
    
23. PipedInputStream getPipedInputStream (){
    
24. return in;
    
25. }
    
26. public void run(){
    
27. byte[] b = new byte[1024];
    
28. try {
    
29. int len = in.read(b);
    
30. System.out.println("The following message comes from sender:/n"+
    
31. new String(b,0,len));
    
32. in.close();
    
33. } catch (IOException e) {
    
34. // TODO Auto-generated catch block
    
35. e.printStackTrace();
    
36. }
    
37. }
    
38. }
    
39. 
    
40. public class Inc {
    
41. public static void main(String[] args){
    
42. Sender sender = new Sender();
    
43. Receiver receiver = new Receiver();
    
44. PipedOutputStream out = sender.getPipedOutputStream();
    
45. PipedInputStream in = receiver.getPipedInputStream();
    
46. try {
    
47. out.connect(in);
    
48. } catch (IOException e) {
    
49. // TODO Auto-generated catch block
    
50. e.printStackTrace();
    
51. }
    
52. sender.start();
    
53. receiver.start();
    
54. }
    
55. 
    
56. }

复制代码

PipedWriter和PipedReader类
·使用管道流类，可以实现各个程序模块之间的松耦合通信。这样可以将多个模块的输入流和输出流相连，拼装成满足需要的应用程序，而不需要修改模块内部代码

问题是否已解决，如已解决请将帖子更改为已解决