java线程通讯
不同线程间进行通信通常有两种简单方法:
方法一 通过访问共享变量的方式(注:需要处理同步问题)
方法二 通过管道流
其中方法一有两种实现方法,即
方法一a)通过内部类实现线程的共享变量
代码如下:
Java代码
/**
* 通过内部类实现线程的共享变量
*
*/
Java代码
1.public class Innersharethread {
2. public static void main(String[] args) {
3. Mythread mythread = new Mythread();
4. mythread.getThread().start();
5. mythread.getThread().start();
6. mythread.getThread().start();
7. mythread.getThread().start();
8. }
9.}
10.class Mythread {
11. int index = 0;
12.
13. private class InnerThread extends Thread {
14. public synchronized void run() {
15. while (true) {
16. System.out.println(Thread.currentThread().getName()
17. + "is running and index is " + index++);
18. }
19. }
20. }
21.
22. public Thread getThread() {
23. return new InnerThread();
24. }
25.}
26.
27./**
28. * 通过内部类实现线程的共享变量
29. *
30. */
31.public class Innersharethread {
32. public static void main(String[] args) {
33. Mythread mythread = new Mythread();
34. mythread.getThread().start();
35. mythread.getThread().start();
36. mythread.getThread().start();
37. mythread.getThread().start();
38. }
39.}
40.class Mythread {
41. int index = 0;
42.
43. private class InnerThread extends Thread {
44. public synchronized void run() {
45. while (true) {
46. System.out.println(Thread.currentThread().getName()
47. + "is running and index is " + index++);
48. }
49. }
50. }
51.
52. public Thread getThread() {
53. return new InnerThread();
54. }
55.}
方法二b)通过实现Runnable接口实现线程的共享变量
代码如下
Java代码
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.}
26.
27./**
28.* 通过实现Runnable接口实现线程的共享变量
29.* @author Administrator
30.*
31.*/
32.public class Interfacaesharethread {
33.public static void main(String[] args) {
34.Mythread mythread = new Mythread();
35.new Thread(mythread).start();
36.new Thread(mythread).start();
37.new Thread(mythread).start();
38.new Thread(mythread).start();
39.}
40.}
41.
42./* 实现Runnable接口 */
43.class Mythread implements Runnable {
44.int index = 0;
45.
46.public synchronized void run() {
47.while (true)
48.System.out.println(Thread.currentThread().getName()
49.+ "is running and the index is " + index++);
50.}
51.}
52.方法二:
53.代码如下
54.Java代码
55.import java.io.IOException;
56.import java.io.PipedInputStream;
57.import java.io.PipedOutputStream;
58.
59.public class CommunicateWhitPiping {
60.public static void main(String[] args) {
61./**
62.* 创建管道输出流
63.*/
64.PipedOutputStream pos = new PipedOutputStream();
65./**
66.* 创建管道输入流
67.*/
68.PipedInputStream pis = new PipedInputStream();
69.try {
70./**
71.* 将管道输入流与输出流连接
72.* 此过程也可通过重载的构造函数来实现
73.*/
74.pos.connect(pis);
75.} catch (IOException e) {
76.e.printStackTrace();
77.}
78./**
79.* 创建生产者线程
80.*/
81.Producer p = new Producer(pos);
82./**
83.* 创建消费者线程
84.*/
85.Consumer c = new Consumer(pis);
86./**
87.* 启动线程
88.*/
89.p.start();
90.c.start();
91.}
92.}
93.
94./**
95.* 生产者线程(与一个管道输入流相关联)
96.*
97.*/
98.class Producer extends Thread {
99.private PipedOutputStream pos;
100.public Producer(PipedOutputStream pos) {
101.this.pos = pos;
102.}
103.public void run() {
104.int i = 8;
105.try {
106.pos.write(i);
107.} catch (IOException e) {
108.e.printStackTrace();
109.}
110.}
111.}
112.
113./**
114.* 消费者线程(与一个管道输入流相关联)
115.*
116.*/
117.class Consumer extends Thread {
118.private PipedInputStream pis;
119.public Consumer(PipedInputStream pis)
120.{
121.this.pis = pis;
122.}
123.public void run() {
124.try {
125.System.out.println(pis.read());
126.} catch (IOException e) {
127.e.printStackTrace();
128.}
129.}
130.}
