java 线程间通信

不同线程间进行通信通常有两种简单方法:
方法一 通过访问共享变量的方式(注:需要处理同步问题)
方法二 通过管道流

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

Java代码

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

/**
 * 通过内部类实现线程的共享变量
 *
 */
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接口实现线程的共享变量
代码如下

Java代码

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

/** 
* 通过实现Runnable接口实现线程的共享变量 
* @author Administrator 
* 
*/ 
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++); 
} 
} 

方法二:
代码如下

Java代码

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