java多線程通訊方法

 進程間通訊的方法主要有如下幾種：

  （1）管道（Pipe）：管道可用於具備親緣關係進程間的通訊，容許一個進程和另外一個與它有共同祖先的進程之間進行通訊。
  （2）命名管道（named pipe）：命名管道克服了管道沒有名字的限制，所以，除具備管道所具備的功能外，它還容許無親緣關 系 進程間的通訊。命名管道在文件系統中有對應的文件名。命名管道經過命令mkfifo或系統調用mkfifo來建立。
  （3）信號（Signal）：信號是比較複雜的通訊方式，用於通知接受進程有某種事件發生，除了用於進程間通訊外，進程還能夠發送 信號給進程自己；linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction（實際上，該函數是基於BSD的，BSD爲了實現可靠信號機制，又可以統一對外接口，用sigaction函數從新實現了signal函數）。
  （4）消息（Message）隊列：消息隊列是消息的連接表，包括Posix消息隊列system V消息隊列。有足夠權限的進程能夠向隊列中添加消息，被賦予讀權限的進程則能夠讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式字節流以及緩衝區大小受限等缺
  （5）共享內存：使得多個進程能夠訪問同一塊內存空間，是最快的可用IPC形式。是針對其餘通訊機制運行效率較低而設計的。每每與其它通訊機制，如信號量結合使用，來達到進程間的同步及互斥。
  （6）內存映射（mapped memory）：內存映射容許任何多個進程間通訊，每個使用該機制的進程經過把一個共享的文件映射到本身的進程地址空間來實現它。
  （7）信號量（semaphore）：主要做爲進程間以及同一進程不一樣線程之間的同步手段。
  （8）套接口（Socket）：更爲通常的進程間通訊機制，可用於不一樣機器之間的進程間通訊。起初是由Unix系統的BSD分支開發出來的，但如今通常能夠移植到其它類Unix系統上：Linux和System V的變種都支持套接字。

而在java中咱們實現多線程間通訊則主要採用"共享變量"和"管道流"這兩種方法

方法一 經過訪問共享變量的方式(注:須要處理同步問題)
方法二 經過管道流

 

其中方法一有兩種實現方法,即
方法一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();
		}
	}
}