线程间的通信，为什么输出线程先执行也能读到信息？解决方法

线程间的通信，为什么输出线程先执行也能读到信息？？？
import   java.io.*;
class   Test
{
                public   static   void   main(String[]   args)
                {
                                PipedOutputStream   pos=new   PipedOutputStream();
                                PipedInputStream   pis=new   PipedInputStream();
                                try
                                {
                                                pos.connect(pis);
                                                new   Consumer(pis).start();         //输出线程先执行
                                                Thread.sleep(3000);                       //而且我还暂停了
                                                new   Producer(pos).start();
                                }
                                catch(Exception   e)
                                {
                                                e.printStackTrace();
                                }
                }
}

class   Producer   extends   Thread
{
                private   PipedOutputStream   pos;
                Producer(PipedOutputStream   pos)
                {
                                this.pos=pos;
                }
                public   void   run()
                {
                                try
                                {
                                                pos.write( "unhappyless ".getBytes());

                                                pos.close();
                                }
                                catch(Exception   e)
                                {
                                                e.printStackTrace();
                                }
                }
}

class   Consumer   extends   Thread
{
                private   PipedInputStream   pis;
                Consumer(PipedInputStream   pis)
                {
                                this.pis=pis;
                }
                public   void   run()
                {
                                try
                                {
                                                byte[]   buf=new   byte[100];
                                                int   len=pis.read(buf);
                                                System.out.println(new   String(buf,0,len));
                                                pis.close();
                                }
                                catch(Exception   e)
                                {
                                                e.printStackTrace();
                                }
                }
}

[解决办法]
IO是阻塞方式的
你先启动的线程，但是没有数据可读
也是堵塞在那里，只到写数据的线程启动并写入数据，读数据的线程的IO流才读到内容

[解决办法]
先执行的Consumer(),并不是说他会先关闭,而是有条件的,只有当你的pis对象读够了100个byte才会执行pis.close,(具体参见PipedInputStream.read()方法)

因此,在他没读到数据之前,他会一直等待,你可以把读的字节数设小一点(小于 "unhappyless "的长度),会发现,没有读完就结束了.
[解决办法]
楼上两位说的不错，虽然你代码中是new Consumer(pis).start(); //输出线程先执行，但是实际上这个线程虽然有可能先获得了cpu，但是io阻塞，最终会保证Producer （）的先执行；
线程的执行顺序是不可控的，如果想要控制的话，我们可以通过synchronized关键字来实行。这部分，楼主可以找点资料看看。。。。
[解决办法]
楼上和楼上的楼上说的话
基本就是我知道了
可能不是根本的原因
但是有相关的因素

我怎么觉得自己在说废话?
[解决办法]
还有个问题的，低优先级并不代表它就一定最后执行，只是执行的机会小而已.