java线程（2）-线程间通信

方法一 通过访问共享变量的方式(注:需要处理同步问题) 
方法二 通过管道流

其中方法一有两种实现方法,即 
方法一a)通过内部类实现线程的共享变量 

public class Innersharethread {     
    public static void main(String[] args) {     
        Mythread mythread = new Mythread();     
        mythread.getThread().start();     
        mythread.getThread().start();     
        mythread.getThread().start();     
        mythread.getThread().start();     
    }     
}     
class Mythread {     
    int index = 0;     
     
    private class InnerThread extends Thread {     
        public synchronized void run() {     
            while (true) {     
                System.out.println(Thread.currentThread().getName()     
                        + "is running and index is " + index++);     
            }     
        }     
    }     
     
    public Thread getThread() {     
        return new InnerThread();     
    }     
}    
   
/** 
 * 通过内部类实现线程的共享变量 
 * 
 */ 
public class Innersharethread {  
    public static void main(String[] args) {  
        Mythread mythread = new Mythread();  
        mythread.getThread().start();  
        mythread.getThread().start();  
        mythread.getThread().start();  
        mythread.getThread().start();  
    }  
}  
class Mythread {  
    int index = 0;  
   
    private class InnerThread extends Thread {  
        public synchronized void run() {  
            while (true) {  
                System.out.println(Thread.currentThread().getName()  
                        + "is running and index is " + index++);  
            }  
        }  
    }  
   
    public Thread getThread() {  
        return new InnerThread();  
    }  
}

b)通过实现Runnable接口实现线程的共享变量 

public class Interfacaesharethread {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        new Thread(mythread).start();
        new Thread(mythread).start();
        new Thread(mythread).start();
        new Thread(mythread).start();
    }
}
 
/* 实现Runnable接口 */
class Mythread implements Runnable {
    int index = 0;
 
    public synchronized void run() {
        while (true)
            System.out.println(Thread.currentThread().getName() + "is running and
                        the index is " + index++);
    }
}
 
/**
 * 通过实现Runnable接口实现线程的共享变量
  
 */
public class Interfacaesharethread {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        new Thread(mythread).start();
        new Thread(mythread).start();
        new Thread(mythread).start();
        new Thread(mythread).start();
    }
}
 
/* 实现Runnable接口 */
class Mythread implements Runnable {
    int index = 0;
 
    public synchronized void run() {
        while (true)
            System.out.println(Thread.currentThread().getName() + "is running and
                        the index is " + index++);
    }
}

方法二(通过管道流）: 

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();
        }
    }
}