guojianhui0906
- 浏览: 46129 次
- 性别:
- 来自: 上海
-
最新评论
-
hanxie1121：
书读多了
思考一下！！！！my android -
huyong479072052：
不用说应届毕业生了，现在中国搞android的开发的有几个能达 ...
思考一下！！！！my android -
zhanhao：
顶！
思考一下！！！！my android -
cectsky：
你妈喊你回家吃饭
回调（callback）方法
[size=medium]JAVA线程间通信问题
有很多现实问题要求不仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？
解决思路
在现实应用中，很多时候都需要让多个线程按照一定的次序来访问共享资源，例如，经典的生产者和消费者问题。这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可以将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。显然，这是一个同步问题，生产者和消费者共享同一资源，并且，生产者和消费者之间彼此依赖，互为条件向前推进。但是，该如何编写程序来解决这个问题呢？
传统的思路是利用循环检测的方式来实现，这种方式通过重复检查某一个特定条件是否成立来决定线程的推进顺序。比如，一旦生产者生产结束，它就继续利用循环检测来判断仓库中的产品是否被消费者消费，而消费者也是在消费结束后就会立即使用循环检测的方式来判断仓库中是否又放进产品。显然，这些操作是很耗费CPU资源的，不值得提倡。那么有没有更好的方法来解决这类问题呢？
首先，当线程在继续执行前需要等待一个条件方可继续执行时，仅有 synchronized 关键字是不够的。因为虽然synchronized关键字可以阻止并发更新同一个共享资源，实现了同步，但是它不能用来实现线程间的消息传递，也就是所谓的通信。而在处理此类问题的时候又必须遵循一种原则，即：对于生产者，在生产者没有生产之前，要通知消费者等待；在生产者生产之后，马上又通知消费者消费；对于消费者，在消费者消费之后，要通知生产者已经消费结束，需要继续生产新的产品以供消费。
其实，Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和 notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。
虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。
这些方法在Object类中声明的语法格式如下所示：
Java代码 收藏代码
1. final void wait() throws InterruptedException
2.
3. final void notify()
4.
5. final void notifyAll()
final void wait() throws InterruptedException
final void notify()
final void notifyAll()
其中，调用wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行态退出，进入等待队列，直到被再次唤醒。而调用notify() 方法可以唤醒等待队列中第一个等待同一共享资源的线程，并使该线程退出等待队列，进入可运行态。调用notifyAll()方法可以使所有正在等待队列中等待同一共享资源的线程从等待状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行。显然，利用这些方法就不必再循环检测共享资源的状态，而是在需要的时候直接唤醒等待队列中的线程就可以了。这样不但节省了宝贵的CPU资源，也提高了程序的效率。
由于wait()方法在声明的时候被声明为抛出InterruptedException异常，因此，在调用wait()方法时，需要将它放入 try…catch代码块中。此外，使用该方法时还需要把它放到一个同步代码段中，否则会出现如下异常：
Java代码 收藏代码
1. Java代码
2. "java.lang.IllegalMonitorStateException: current thread not owner"
3.
Java代码
"java.lang.IllegalMonitorStateException: current thread not owner"
这些方法是不是就可以实现线程间的通信了呢？下面将通过多线程同步的模型: 生产者和消费者问题来说明怎样通过程序解决多线程间的通信问题。
具体步骤
下面这个程序演示了多个线程之间进行通信的具体实现过程。程序中用到了4个类，其中ShareData类用来定义共享数据和同步方法。在同步方法中调用了wait()方法和notify()方法，并通过一个信号量来实现线程间的消息传递。
Java代码 收藏代码
1. Java代码
2. // 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
3.
4. class ShareData
5.
6. {
7. private char c;
8. private boolean isProduced = false; // 信号量
9. public synchronized void putShareChar(char c) // 同步方法putShareChar()
10. {
11. if (isProduced) // 如果产品还未消费，则生产者等待
12. {
13. try
14. {
15. wait(); // 生产者等待
16. } catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20. this.c = c;
21. isProduced = true; // 标记已经生产
22. notify(); // 通知消费者已经生产，可以消费
23. }
24.
25. public synchronized char getShareChar() // 同步方法getShareChar()
26. {
27. if (!isProduced) // 如果产品还未生产，则消费者等待
28. {
29. try
30. {
31. wait(); // 消费者等待
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. }
36. isProduced = false; // 标记已经消费
37. notify(); // 通知需要生产
38. return this.c;
39. }
40. }
41.
42. class Producer extends Thread // 生产者线程
43. {
44. private ShareData s;
45.
46. Producer(ShareData s)
47. {
48. this.s = s;
49. }
50.
51. public void run()
52. {
53. for (char ch = 'A'; ch <= 'D'; ch++)
54. {
55. try
56. {
57. Thread.sleep((int) (Math.random() * 3000));
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. }
61. s.putShareChar(ch); // 将产品放入仓库
62. System.out.println(ch + " is produced by Producer.");
63. }
64. }
65. }
66.
67. class Consumer extends Thread // 消费者线程
68. {
69. private ShareData s;
70.
71. Consumer(ShareData s)
72. {
73. this.s = s;
74. }
75.
76. public void run()
77. {
78. char ch;
79. do {
80. try
81. {
82. Thread.sleep((int) (Math.random() * 3000));
83. } catch (InterruptedException e) {
84. e.printStackTrace();
85. }
86. ch = s.getShareChar(); // 从仓库中取出产品
87. System.out.println(ch + " is consumed by Consumer. ");
88. } while (ch != 'D');
89. }
90. }
91.
92. class CommunicationDemo
93. {
94. public static void main(String[] args)
95. {
96. ShareData s = new ShareData();
97. new Consumer(s).start();
98. new Producer(s).start();
99. }
100. }
Java代码
// 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
class ShareData
{
private char c;
private boolean isProduced = false; // 信号量
public synchronized void putShareChar(char c) // 同步方法putShareChar()
{
if (isProduced) // 如果产品还未消费，则生产者等待
{
try
{
wait(); // 生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.c = c;
isProduced = true; // 标记已经生产
notify(); // 通知消费者已经生产，可以消费
}
public synchronized char getShareChar() // 同步方法getShareChar()
{
if (!isProduced) // 如果产品还未生产，则消费者等待
{
try
{
wait(); // 消费者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isProduced = false; // 标记已经消费
notify(); // 通知需要生产
return this.c;
}
}
class Producer extends Thread // 生产者线程
{
private ShareData s;
Producer(ShareData s)
{
this.s = s;
}
public void run()
{
for (char ch = 'A'; ch <= 'D'; ch++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
s.putShareChar(ch); // 将产品放入仓库
System.out.println(ch + " is produced by Producer.");
}
}
}
class Consumer extends Thread // 消费者线程
{
private ShareData s;
Consumer(ShareData s)
{
this.s = s;
}
public void run()
{
char ch;
do {
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
ch = s.getShareChar(); // 从仓库中取出产品
System.out.println(ch + " is consumed by Consumer. ");
} while (ch != 'D');
}
}
class CommunicationDemo
{
public static void main(String[] args)
{
ShareData s = new ShareData();
new Consumer(s).start();
new Producer(s).start();
}
}
上面的程序演示了生产者生产出A、B、C、D四个字符，消费者消费这四个字符的全过程
通过程序的运行结果可以看到，尽管在主方法中先启动了Consumer线程，但是，由于仓库中没有产品，因此，Consumer线程就会调用 wait()方法进入等待队列进行等待，直到Producer线程将产品生产出来并放进仓库，然后使用notify()方法将其唤醒。
由于在两个线程中都指定了一定的休眠时间，因此也可能出现这样的情况：生产者将产品生产出来放入仓库，并通知等待队列中的Consumer线程，然而，由于休眠时间过长，Consumer线程还没有打算消费产品，此时，Producer线程欲生产下一个产品，结果由于仓库中的产品没有被消费掉，故 Producer线程执行wait()方法进入等待队列等待，直到Consumer线程将仓库中的产品消费掉以后通过notify()方法去唤醒等待队列中的Producer线程为止。可见，两个线程之间除了必须保持同步之外，还要通过相互通信才能继续向前推进。
前面这个程序中，生产者一次只能生产一个产品，而消费者也只能一次消费一个产品。那么现实中也有这样的情况，生产者可以一次生产多个产品，只要仓库容量够大，就可以一直生产。而消费者也可以一次消费多个产品，直到仓库中没有产品为止。
但是，无论是生产产品到仓库，还是从仓库中消费，每一次都只能允许一个操作。显然，这也是个同步问题，只不过在这个问题中共享资源是一个资源池，可以存放多个资源。下面就以栈结构为例给出如何在这个问题中解决线程通信的程序代码。
Java代码 收藏代码
1. // 例4.6.2 CommunicationDemo2.java
2.
3. class SyncStack // 同步堆栈类，可以一次放入多个数据
4. {
5. private int index = 0; // 堆栈指针初始值为0
6. private char[] buffer = new char[5]; // 堆栈有5个字符的空间
7. public synchronized void push(char c) // 入栈同步方法
8. {
9. if (index == buffer.length) // 堆栈已满，不能入栈
10. {
11. try
12. {
13. this.wait(); // 等待出栈线程将数据出栈
14. } catch (InterruptedException e) {
15. }
16. }
17. buffer[index] = c; // 数据入栈
18. index++; // 指针加1，栈内空间减少
19. this.notify(); // 通知其他线程把数据出栈
20. }
21.
22. public synchronized char pop() // 出栈同步方法
23. {
24. if (index == 0) // 堆栈无数据，不能出栈
25. {
26. try
27. {
28. this.wait(); // 等待入栈线程把数据入栈
29. } catch (InterruptedException e) {
30. }
31. }
32. this.notify(); // 通知其他线程入栈
33. index--; // 指针向下移动
34. return buffer[index]; // 数据出栈
35. }
36. }
37.
38. class Producer implements Runnable // 生产者类
39. {
40. SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
41. public Producer(SyncStack s)
42. {
43. this.s = s;
44. }
45.
46. public void run()
47. {
48. char ch;
49. for (int i = 0; i < 5; i++)
50. {
51. try
52. {
53. Thread.sleep((int) (Math.random() * 1000));
54. } catch (InterruptedException e) {
55. }
56. ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
57. s.push(ch); // 把字符入栈
58. System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
59. }
60. }
61. }
62.
63. class Consumer implements Runnable // 消费者类
64. {
65. SyncStack s; // 消费者类获得的字符都来自同步堆栈
66. public Consumer(SyncStack s)
67. {
68. this.s = s;
69. }
70.
71. public void run()
72. {
73. char ch;
74. for (int i = 0; i < 5; i++)
75. {
76. try
77. {
78. Thread.sleep((int) (Math.random() * 3000));
79. } catch (InterruptedException e) {
80. }
81. ch = s.pop(); // 从堆栈中读取字符
82. System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
83. }
84. }
85. }
86.
87. public class CommunicationDemo2
88. {
89. public static void main(String[] args)
90. {
91. SyncStack stack = new SyncStack();
92. // 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
93. Thread t1 = new Thread(new Producer(stack)); // 线程实例化
94. Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
95. t2.start(); // 线程启动
96. t1.start(); // 线程启动
97. }
98. }
// 例4.6.2 CommunicationDemo2.java
class SyncStack // 同步堆栈类，可以一次放入多个数据
{
private int index = 0; // 堆栈指针初始值为0
private char[] buffer = new char[5]; // 堆栈有5个字符的空间
public synchronized void push(char c) // 入栈同步方法
{
if (index == buffer.length) // 堆栈已满，不能入栈
{
try
{
this.wait(); // 等待出栈线程将数据出栈
} catch (InterruptedException e) {
}
}
buffer[index] = c; // 数据入栈
index++; // 指针加1，栈内空间减少
this.notify(); // 通知其他线程把数据出栈
}
public synchronized char pop() // 出栈同步方法
{
if (index == 0) // 堆栈无数据，不能出栈
{
try
{
this.wait(); // 等待入栈线程把数据入栈
} catch (InterruptedException e) {
}
}
this.notify(); // 通知其他线程入栈
index--; // 指针向下移动
return buffer[index]; // 数据出栈
}
}
class Producer implements Runnable // 生产者类
{
SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
public Producer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
s.push(ch); // 把字符入栈
System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
}
}
}
JAVA线程间通信问题
有很多现实问题要求不仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？
解决思路
在现实应用中，很多时候都需要让多个线程按照一定的次序来访问共享资源，例如，经典的生产者和消费者问题。这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可以将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。显然，这是一个同步问题，生产者和消费者共享同一资源，并且，生产者和消费者之间彼此依赖，互为条件向前推进。但是，该如何编写程序来解决这个问题呢？
传统的思路是利用循环检测的方式来实现，这种方式通过重复检查某一个特定条件是否成立来决定线程的推进顺序。比如，一旦生产者生产结束，它就继续利用循环检测来判断仓库中的产品是否被消费者消费，而消费者也是在消费结束后就会立即使用循环检测的方式来判断仓库中是否又放进产品。显然，这些操作是很耗费CPU资源的，不值得提倡。那么有没有更好的方法来解决这类问题呢？
首先，当线程在继续执行前需要等待一个条件方可继续执行时，仅有 synchronized 关键字是不够的。因为虽然synchronized关键字可以阻止并发更新同一个共享资源，实现了同步，但是它不能用来实现线程间的消息传递，也就是所谓的通信。而在处理此类问题的时候又必须遵循一种原则，即：对于生产者，在生产者没有生产之前，要通知消费者等待；在生产者生产之后，马上又通知消费者消费；对于消费者，在消费者消费之后，要通知生产者已经消费结束，需要继续生产新的产品以供消费。
其实，Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和 notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。
虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。
这些方法在Object类中声明的语法格式如下所示：
Java代码 收藏代码
1. final void wait() throws InterruptedException
2.
3. final void notify()
4.
5. final void notifyAll()
final void wait() throws InterruptedException
final void notify()
final void notifyAll()
其中，调用wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行态退出，进入等待队列，直到被再次唤醒。而调用notify() 方法可以唤醒等待队列中第一个等待同一共享资源的线程，并使该线程退出等待队列，进入可运行态。调用notifyAll()方法可以使所有正在等待队列中等待同一共享资源的线程从等待状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行。显然，利用这些方法就不必再循环检测共享资源的状态，而是在需要的时候直接唤醒等待队列中的线程就可以了。这样不但节省了宝贵的CPU资源，也提高了程序的效率。
由于wait()方法在声明的时候被声明为抛出InterruptedException异常，因此，在调用wait()方法时，需要将它放入 try…catch代码块中。此外，使用该方法时还需要把它放到一个同步代码段中，否则会出现如下异常：
Java代码 收藏代码
1. Java代码
2. "java.lang.IllegalMonitorStateException: current thread not owner"
3.
Java代码
"java.lang.IllegalMonitorStateException: current thread not owner"
这些方法是不是就可以实现线程间的通信了呢？下面将通过多线程同步的模型: 生产者和消费者问题来说明怎样通过程序解决多线程间的通信问题。
具体步骤
下面这个程序演示了多个线程之间进行通信的具体实现过程。程序中用到了4个类，其中ShareData类用来定义共享数据和同步方法。在同步方法中调用了wait()方法和notify()方法，并通过一个信号量来实现线程间的消息传递。
Java代码 收藏代码
1. Java代码
2. // 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
3.
4. class ShareData
5.
6. {
7. private char c;
8. private boolean isProduced = false; // 信号量
9. public synchronized void putShareChar(char c) // 同步方法putShareChar()
10. {
11. if (isProduced) // 如果产品还未消费，则生产者等待
12. {
13. try
14. {
15. wait(); // 生产者等待
16. } catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20. this.c = c;
21. isProduced = true; // 标记已经生产
22. notify(); // 通知消费者已经生产，可以消费
23. }
24.
25. public synchronized char getShareChar() // 同步方法getShareChar()
26. {
27. if (!isProduced) // 如果产品还未生产，则消费者等待
28. {
29. try
30. {
31. wait(); // 消费者等待
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. }
36. isProduced = false; // 标记已经消费
37. notify(); // 通知需要生产
38. return this.c;
39. }
40. }
41.
42. class Producer extends Thread // 生产者线程
43. {
44. private ShareData s;
45.
46. Producer(ShareData s)
47. {
48. this.s = s;
49. }
50.
51. public void run()
52. {
53. for (char ch = 'A'; ch <= 'D'; ch++)
54. {
55. try
56. {
57. Thread.sleep((int) (Math.random() * 3000));
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. }
61. s.putShareChar(ch); // 将产品放入仓库
62. System.out.println(ch + " is produced by Producer.");
63. }
64. }
65. }
66.
67. class Consumer extends Thread // 消费者线程
68. {
69. private ShareData s;
70.
71. Consumer(ShareData s)
72. {
73. this.s = s;
74. }
75.
76. public void run()
77. {
78. char ch;
79. do {
80. try
81. {
82. Thread.sleep((int) (Math.random() * 3000));
83. } catch (InterruptedException e) {
84. e.printStackTrace();
85. }
86. ch = s.getShareChar(); // 从仓库中取出产品
87. System.out.println(ch + " is consumed by Consumer. ");
88. } while (ch != 'D');
89. }
90. }
91.
92. class CommunicationDemo
93. {
94. public static void main(String[] args)
95. {
96. ShareData s = new ShareData();
97. new Consumer(s).start();
98. new Producer(s).start();
99. }
100. }
Java代码
// 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
class ShareData
{
private char c;
private boolean isProduced = false; // 信号量
public synchronized void putShareChar(char c) // 同步方法putShareChar()
{
if (isProduced) // 如果产品还未消费，则生产者等待
{
try
{
wait(); // 生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.c = c;
isProduced = true; // 标记已经生产
notify(); // 通知消费者已经生产，可以消费
}
public synchronized char getShareChar() // 同步方法getShareChar()
{
if (!isProduced) // 如果产品还未生产，则消费者等待
{
try
{
wait(); // 消费者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isProduced = false; // 标记已经消费
notify(); // 通知需要生产
return this.c;
}
}
class Producer extends Thread // 生产者线程
{
private ShareData s;
Producer(ShareData s)
{
this.s = s;
}
public void run()
{
for (char ch = 'A'; ch <= 'D'; ch++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
s.putShareChar(ch); // 将产品放入仓库
System.out.println(ch + " is produced by Producer.");
}
}
}
class Consumer extends Thread // 消费者线程
{
private ShareData s;
Consumer(ShareData s)
{
this.s = s;
}
public void run()
{
char ch;
do {
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
ch = s.getShareChar(); // 从仓库中取出产品
System.out.println(ch + " is consumed by Consumer. ");
} while (ch != 'D');
}
}
class CommunicationDemo
{
public static void main(String[] args)
{
ShareData s = new ShareData();
new Consumer(s).start();
new Producer(s).start();
}
}
上面的程序演示了生产者生产出A、B、C、D四个字符，消费者消费这四个字符的全过程
通过程序的运行结果可以看到，尽管在主方法中先启动了Consumer线程，但是，由于仓库中没有产品，因此，Consumer线程就会调用 wait()方法进入等待队列进行等待，直到Producer线程将产品生产出来并放进仓库，然后使用notify()方法将其唤醒。
由于在两个线程中都指定了一定的休眠时间，因此也可能出现这样的情况：生产者将产品生产出来放入仓库，并通知等待队列中的Consumer线程，然而，由于休眠时间过长，Consumer线程还没有打算消费产品，此时，Producer线程欲生产下一个产品，结果由于仓库中的产品没有被消费掉，故 Producer线程执行wait()方法进入等待队列等待，直到Consumer线程将仓库中的产品消费掉以后通过notify()方法去唤醒等待队列中的Producer线程为止。可见，两个线程之间除了必须保持同步之外，还要通过相互通信才能继续向前推进。
前面这个程序中，生产者一次只能生产一个产品，而消费者也只能一次消费一个产品。那么现实中也有这样的情况，生产者可以一次生产多个产品，只要仓库容量够大，就可以一直生产。而消费者也可以一次消费多个产品，直到仓库中没有产品为止。
但是，无论是生产产品到仓库，还是从仓库中消费，每一次都只能允许一个操作。显然，这也是个同步问题，只不过在这个问题中共享资源是一个资源池，可以存放多个资源。下面就以栈结构为例给出如何在这个问题中解决线程通信的程序代码。
Java代码 收藏代码
1. // 例4.6.2 CommunicationDemo2.java
2.
3. class SyncStack // 同步堆栈类，可以一次放入多个数据
4. {
5. private int index = 0; // 堆栈指针初始值为0
6. private char[] buffer = new char[5]; // 堆栈有5个字符的空间
7. public synchronized void push(char c) // 入栈同步方法
8. {
9. if (index == buffer.length) // 堆栈已满，不能入栈
10. {
11. try
12. {
13. this.wait(); // 等待出栈线程将数据出栈
14. } catch (InterruptedException e) {
15. }
16. }
17. buffer[index] = c; // 数据入栈
18. index++; // 指针加1，栈内空间减少
19. this.notify(); // 通知其他线程把数据出栈
20. }
21.
22. public synchronized char pop() // 出栈同步方法
23. {
24. if (index == 0) // 堆栈无数据，不能出栈
25. {
26. try
27. {
28. this.wait(); // 等待入栈线程把数据入栈
29. } catch (InterruptedException e) {
30. }
31. }
32. this.notify(); // 通知其他线程入栈
33. index--; // 指针向下移动
34. return buffer[index]; // 数据出栈
35. }
36. }
37.
38. class Producer implements Runnable // 生产者类
39. {
40. SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
41. public Producer(SyncStack s)
42. {
43. this.s = s;
44. }
45.
46. public void run()
47. {
48. char ch;
49. for (int i = 0; i < 5; i++)
50. {
51. try
52. {
53. Thread.sleep((int) (Math.random() * 1000));
54. } catch (InterruptedException e) {
55. }
56. ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
57. s.push(ch); // 把字符入栈
58. System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
59. }
60. }
61. }
62.
63. class Consumer implements Runnable // 消费者类
64. {
65. SyncStack s; // 消费者类获得的字符都来自同步堆栈
66. public Consumer(SyncStack s)
67. {
68. this.s = s;
69. }
70.
71. public void run()
72. {
73. char ch;
74. for (int i = 0; i < 5; i++)
75. {
76. try
77. {
78. Thread.sleep((int) (Math.random() * 3000));
79. } catch (InterruptedException e) {
80. }
81. ch = s.pop(); // 从堆栈中读取字符
82. System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
83. }
84. }
85. }
86.
87. public class CommunicationDemo2
88. {
89. public static void main(String[] args)
90. {
91. SyncStack stack = new SyncStack();
92. // 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
93. Thread t1 = new Thread(new Producer(stack)); // 线程实例化
94. Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
95. t2.start(); // 线程启动
96. t1.start(); // 线程启动
97. }
98. }
// 例4.6.2 CommunicationDemo2.java
class SyncStack // 同步堆栈类，可以一次放入多个数据
{
private int index = 0; // 堆栈指针初始值为0
private char[] buffer = new char[5]; // 堆栈有5个字符的空间
public synchronized void push(char c) // 入栈同步方法
{
if (index == buffer.length) // 堆栈已满，不能入栈
{
try
{
this.wait(); // 等待出栈线程将数据出栈
} catch (InterruptedException e) {
}
}
buffer[index] = c; // 数据入栈
index++; // 指针加1，栈内空间减少
this.notify(); // 通知其他线程把数据出栈
}
public synchronized char pop() // 出栈同步方法
{
if (index == 0) // 堆栈无数据，不能出栈
{
try
{
this.wait(); // 等待入栈线程把数据入栈
} catch (InterruptedException e) {
}
}
this.notify(); // 通知其他线程入栈
index--; // 指针向下移动
return buffer[index]; // 数据出栈
}
}
class Producer implements Runnable // 生产者类
{
SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
public Producer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
s.push(ch); // 把字符入栈
System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
}
}
}
class Consumer implements Runnable // 消费者类
{
SyncStack s; // 消费者类获得的字符都来自同步堆栈
public Consumer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
}
ch = s.pop(); // 从堆栈中读取字符
System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
}
}
}
public class CommunicationDemo2
{
public static void main(String[] args)
{
SyncStack stack = new SyncStack();
// 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
Thread t1 = new Thread(new Producer(stack)); // 线程实例化
Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
t2.start(); // 线程启动
t1.start(); // 线程启动
}
}
程序中引入了一个堆栈数组buffer[]来模拟资源池，并使生产者类和消费者类都实现了Runnable接口，然后在主程序中通过前面介绍的方法创建两个共享同一堆栈资源的线程，并且有意先启动消费者线程，后启动生产者线程。请在阅读程序的时候仔细观察例4.6.1和本例的相似点以及区别之处，体会作者的用心。
由于是栈结构，所以符合后进先出原则。有兴趣的读者还可以用符合先进先出原则的队列结构来模拟线程间通信的过程，相信可以通过查阅相关的资料来解决这个问题，在这里就不再给出程序代码了，作为一个思考题供读者练习。
专家说明
本小节介绍了三个重要的方法：wait()、notify()和notifyAll()。使用它们可以高效率地完成多个线程间的通信问题，这样在通信问题上就不必再使用循环检测的方法来等待某个条件的发生，因为这种方法是极为浪费CPU资源的，当然这种情况也不是所期望的。在例4.6.1中，为了更好地通信，引入了一个专门用来传递信息的信号量。利用信号量来决定线程是否等待无疑是一种非常安全的操作，值得提倡。此外，在例4.6.2中引入了资源池作为共享资源，并解决了在这种情况下如何实现多线程之间的通信问题。希望读者能够举一反三，编写出解决更加复杂问题的程序。
专家指点
可以肯定的是，合理地使用wait()、notify()和notifyAll()方法确实能够很好地解决线程间通信的问题。但是，也应该了解到这些方法是更复杂的锁定、排队和并发性代码的构件。尤其是使用 notify()来代替notifyAll()时是有风险的。除非确实知道每一个线程正在做什么，否则最好使用notifyAll()。其实，在 JDK1.5中已经引入了一个新的包：java.util.concurrent 包，该包是一个被广泛使用的开放源码工具箱，里面都是有用的并发性实用程序。完全可以代替wait()和notify()方法用来编写自己的调度程序和锁。有关信息可以查阅相关资料，本书中不再赘述。
相关问题
Java提供了各种各样的输入输出流(stream)，使程序员能够很方便地对数据进行操作。其中，管道(pipe)流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读出数据。通过使用管道，达到实现多个线程间通信的目的。那么，如何创建和使用管道呢？
Java提供了两个特殊的专门用来处理管道的类，它们就是PipedInputStream类和PipedOutputStream类。
其中，PipedInputStream代表了数据在管道中的输出端，也就是线程从管道读出数据的一端；PipedOutputStream代表了数据在管道中的输入端，也就是线程向管道写入数据的一端，这两个类一起使用就可以创建出数据输入输出的管道流对象。
一旦创建了管道之后，就可以利用多线程的通信机制对磁盘中的文件通过管道进行数据的读写，从而使多线程的程序设计在实际应用中发挥更大的作用。
class Consumer implements Runnable // 消费者类
{
SyncStack s; // 消费者类获得的字符都来自同步堆栈
public Consumer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
}
ch = s.pop(); // 从堆栈中读取字符
System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
}
}
}
public class CommunicationDemo2
{
public static void main(String[] args)
{
SyncStack stack = new SyncStack();
// 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
Thread t1 = new Thread(new Producer(stack)); // 线程实例化
Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
t2.start(); // 线程启动
t1.start(); // 线程启动
}
}
程序中引入了一个堆栈数组buffer[]来模拟资源池，并使生产者类和消费者类都实现了Runnable接口，然后在主程序中通过前面介绍的方法创建两个共享同一堆栈资源的线程，并且有意先启动消费者线程，后启动生产者线程。请在阅读程序的时候仔细观察例4.6.1和本例的相似点以及区别之处，体会作者的用心。
由于是栈结构，所以符合后进先出原则。有兴趣的读者还可以用符合先进先出原则的队列结构来模拟线程间通信的过程，相信可以通过查阅相关的资料来解决这个问题，在这里就不再给出程序代码了，作为一个思考题供读者练习。
专家说明
本小节介绍了三个重要的方法：wait()、notify()和notifyAll()。使用它们可以高效率地完成多个线程间的通信问题，这样在通信问题上就不必再使用循环检测的方法来等待某个条件的发生，因为这种方法是极为浪费CPU资源的，当然这种情况也不是所期望的。在例4.6.1中，为了更好地通信，引入了一个专门用来传递信息的信号量。利用信号量来决定线程是否等待无疑是一种非常安全的操作，值得提倡。此外，在例4.6.2中引入了资源池作为共享资源，并解决了在这种情况下如何实现多线程之间的通信问题。希望读者能够举一反三，编写出解决更加复杂问题的程序。
专家指点
可以肯定的是，合理地使用wait()、notify()和notifyAll()方法确实能够很好地解决线程间通信的问题。但是，也应该了解到这些方法是更复杂的锁定、排队和并发性代码的构件。尤其是使用 notify()来代替notifyAll()时是有风险的。除非确实知道每一个线程正在做什么，否则最好使用notifyAll()。其实，在 JDK1.5中已经引入了一个新的包：java.util.concurrent 包，该包是一个被广泛使用的开放源码工具箱，里面都是有用的并发性实用程序。完全可以代替wait()和notify()方法用来编写自己的调度程序和锁。有关信息可以查阅相关资料，本书中不再赘述。
相关问题
Java提供了各种各样的输入输出流(stream)，使程序员能够很方便地对数据进行操作。其中，管道(pipe)流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读出数据。通过使用管道，达到实现多个线程间通信的目的。那么，如何创建和使用管道呢？
Java提供了两个特殊的专门用来处理管道的类，它们就是PipedInputStream类和PipedOutputStream类。
其中，PipedInputStream代表了数据在管道中的输出端，也就是线程从管道读出数据的一端；PipedOutputStream代表了数据在管道中的输入端，也就是线程向管道写入数据的一端，这两个类一起使用就可以创建出数据输入输出的管道流对象。
一旦创建了管道之后，就可以利用多线程的通信机制对磁盘中的文件通过管道进行数据的读写，从而使多线程的程序设计在实际应用中发挥更大的作用。 [/size]
有很多现实问题要求不仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？
解决思路
在现实应用中，很多时候都需要让多个线程按照一定的次序来访问共享资源，例如，经典的生产者和消费者问题。这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可以将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。显然，这是一个同步问题，生产者和消费者共享同一资源，并且，生产者和消费者之间彼此依赖，互为条件向前推进。但是，该如何编写程序来解决这个问题呢？
传统的思路是利用循环检测的方式来实现，这种方式通过重复检查某一个特定条件是否成立来决定线程的推进顺序。比如，一旦生产者生产结束，它就继续利用循环检测来判断仓库中的产品是否被消费者消费，而消费者也是在消费结束后就会立即使用循环检测的方式来判断仓库中是否又放进产品。显然，这些操作是很耗费CPU资源的，不值得提倡。那么有没有更好的方法来解决这类问题呢？
首先，当线程在继续执行前需要等待一个条件方可继续执行时，仅有 synchronized 关键字是不够的。因为虽然synchronized关键字可以阻止并发更新同一个共享资源，实现了同步，但是它不能用来实现线程间的消息传递，也就是所谓的通信。而在处理此类问题的时候又必须遵循一种原则，即：对于生产者，在生产者没有生产之前，要通知消费者等待；在生产者生产之后，马上又通知消费者消费；对于消费者，在消费者消费之后，要通知生产者已经消费结束，需要继续生产新的产品以供消费。
其实，Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和 notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。
虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。
这些方法在Object类中声明的语法格式如下所示：
Java代码 收藏代码
1. final void wait() throws InterruptedException
2.
3. final void notify()
4.
5. final void notifyAll()
final void wait() throws InterruptedException
final void notify()
final void notifyAll()
其中，调用wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行态退出，进入等待队列，直到被再次唤醒。而调用notify() 方法可以唤醒等待队列中第一个等待同一共享资源的线程，并使该线程退出等待队列，进入可运行态。调用notifyAll()方法可以使所有正在等待队列中等待同一共享资源的线程从等待状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行。显然，利用这些方法就不必再循环检测共享资源的状态，而是在需要的时候直接唤醒等待队列中的线程就可以了。这样不但节省了宝贵的CPU资源，也提高了程序的效率。
由于wait()方法在声明的时候被声明为抛出InterruptedException异常，因此，在调用wait()方法时，需要将它放入 try…catch代码块中。此外，使用该方法时还需要把它放到一个同步代码段中，否则会出现如下异常：
Java代码 收藏代码
1. Java代码
2. "java.lang.IllegalMonitorStateException: current thread not owner"
3.
Java代码
"java.lang.IllegalMonitorStateException: current thread not owner"
这些方法是不是就可以实现线程间的通信了呢？下面将通过多线程同步的模型: 生产者和消费者问题来说明怎样通过程序解决多线程间的通信问题。
具体步骤
下面这个程序演示了多个线程之间进行通信的具体实现过程。程序中用到了4个类，其中ShareData类用来定义共享数据和同步方法。在同步方法中调用了wait()方法和notify()方法，并通过一个信号量来实现线程间的消息传递。
Java代码 收藏代码
1. Java代码
2. // 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
3.
4. class ShareData
5.
6. {
7. private char c;
8. private boolean isProduced = false; // 信号量
9. public synchronized void putShareChar(char c) // 同步方法putShareChar()
10. {
11. if (isProduced) // 如果产品还未消费，则生产者等待
12. {
13. try
14. {
15. wait(); // 生产者等待
16. } catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20. this.c = c;
21. isProduced = true; // 标记已经生产
22. notify(); // 通知消费者已经生产，可以消费
23. }
24.
25. public synchronized char getShareChar() // 同步方法getShareChar()
26. {
27. if (!isProduced) // 如果产品还未生产，则消费者等待
28. {
29. try
30. {
31. wait(); // 消费者等待
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. }
36. isProduced = false; // 标记已经消费
37. notify(); // 通知需要生产
38. return this.c;
39. }
40. }
41.
42. class Producer extends Thread // 生产者线程
43. {
44. private ShareData s;
45.
46. Producer(ShareData s)
47. {
48. this.s = s;
49. }
50.
51. public void run()
52. {
53. for (char ch = 'A'; ch <= 'D'; ch++)
54. {
55. try
56. {
57. Thread.sleep((int) (Math.random() * 3000));
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. }
61. s.putShareChar(ch); // 将产品放入仓库
62. System.out.println(ch + " is produced by Producer.");
63. }
64. }
65. }
66.
67. class Consumer extends Thread // 消费者线程
68. {
69. private ShareData s;
70.
71. Consumer(ShareData s)
72. {
73. this.s = s;
74. }
75.
76. public void run()
77. {
78. char ch;
79. do {
80. try
81. {
82. Thread.sleep((int) (Math.random() * 3000));
83. } catch (InterruptedException e) {
84. e.printStackTrace();
85. }
86. ch = s.getShareChar(); // 从仓库中取出产品
87. System.out.println(ch + " is consumed by Consumer. ");
88. } while (ch != 'D');
89. }
90. }
91.
92. class CommunicationDemo
93. {
94. public static void main(String[] args)
95. {
96. ShareData s = new ShareData();
97. new Consumer(s).start();
98. new Producer(s).start();
99. }
100. }
Java代码
// 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
class ShareData
{
private char c;
private boolean isProduced = false; // 信号量
public synchronized void putShareChar(char c) // 同步方法putShareChar()
{
if (isProduced) // 如果产品还未消费，则生产者等待
{
try
{
wait(); // 生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.c = c;
isProduced = true; // 标记已经生产
notify(); // 通知消费者已经生产，可以消费
}
public synchronized char getShareChar() // 同步方法getShareChar()
{
if (!isProduced) // 如果产品还未生产，则消费者等待
{
try
{
wait(); // 消费者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isProduced = false; // 标记已经消费
notify(); // 通知需要生产
return this.c;
}
}
class Producer extends Thread // 生产者线程
{
private ShareData s;
Producer(ShareData s)
{
this.s = s;
}
public void run()
{
for (char ch = 'A'; ch <= 'D'; ch++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
s.putShareChar(ch); // 将产品放入仓库
System.out.println(ch + " is produced by Producer.");
}
}
}
class Consumer extends Thread // 消费者线程
{
private ShareData s;
Consumer(ShareData s)
{
this.s = s;
}
public void run()
{
char ch;
do {
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
ch = s.getShareChar(); // 从仓库中取出产品
System.out.println(ch + " is consumed by Consumer. ");
} while (ch != 'D');
}
}
class CommunicationDemo
{
public static void main(String[] args)
{
ShareData s = new ShareData();
new Consumer(s).start();
new Producer(s).start();
}
}
上面的程序演示了生产者生产出A、B、C、D四个字符，消费者消费这四个字符的全过程
通过程序的运行结果可以看到，尽管在主方法中先启动了Consumer线程，但是，由于仓库中没有产品，因此，Consumer线程就会调用 wait()方法进入等待队列进行等待，直到Producer线程将产品生产出来并放进仓库，然后使用notify()方法将其唤醒。
由于在两个线程中都指定了一定的休眠时间，因此也可能出现这样的情况：生产者将产品生产出来放入仓库，并通知等待队列中的Consumer线程，然而，由于休眠时间过长，Consumer线程还没有打算消费产品，此时，Producer线程欲生产下一个产品，结果由于仓库中的产品没有被消费掉，故 Producer线程执行wait()方法进入等待队列等待，直到Consumer线程将仓库中的产品消费掉以后通过notify()方法去唤醒等待队列中的Producer线程为止。可见，两个线程之间除了必须保持同步之外，还要通过相互通信才能继续向前推进。
前面这个程序中，生产者一次只能生产一个产品，而消费者也只能一次消费一个产品。那么现实中也有这样的情况，生产者可以一次生产多个产品，只要仓库容量够大，就可以一直生产。而消费者也可以一次消费多个产品，直到仓库中没有产品为止。
但是，无论是生产产品到仓库，还是从仓库中消费，每一次都只能允许一个操作。显然，这也是个同步问题，只不过在这个问题中共享资源是一个资源池，可以存放多个资源。下面就以栈结构为例给出如何在这个问题中解决线程通信的程序代码。
Java代码 收藏代码
1. // 例4.6.2 CommunicationDemo2.java
2.
3. class SyncStack // 同步堆栈类，可以一次放入多个数据
4. {
5. private int index = 0; // 堆栈指针初始值为0
6. private char[] buffer = new char[5]; // 堆栈有5个字符的空间
7. public synchronized void push(char c) // 入栈同步方法
8. {
9. if (index == buffer.length) // 堆栈已满，不能入栈
10. {
11. try
12. {
13. this.wait(); // 等待出栈线程将数据出栈
14. } catch (InterruptedException e) {
15. }
16. }
17. buffer[index] = c; // 数据入栈
18. index++; // 指针加1，栈内空间减少
19. this.notify(); // 通知其他线程把数据出栈
20. }
21.
22. public synchronized char pop() // 出栈同步方法
23. {
24. if (index == 0) // 堆栈无数据，不能出栈
25. {
26. try
27. {
28. this.wait(); // 等待入栈线程把数据入栈
29. } catch (InterruptedException e) {
30. }
31. }
32. this.notify(); // 通知其他线程入栈
33. index--; // 指针向下移动
34. return buffer[index]; // 数据出栈
35. }
36. }
37.
38. class Producer implements Runnable // 生产者类
39. {
40. SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
41. public Producer(SyncStack s)
42. {
43. this.s = s;
44. }
45.
46. public void run()
47. {
48. char ch;
49. for (int i = 0; i < 5; i++)
50. {
51. try
52. {
53. Thread.sleep((int) (Math.random() * 1000));
54. } catch (InterruptedException e) {
55. }
56. ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
57. s.push(ch); // 把字符入栈
58. System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
59. }
60. }
61. }
62.
63. class Consumer implements Runnable // 消费者类
64. {
65. SyncStack s; // 消费者类获得的字符都来自同步堆栈
66. public Consumer(SyncStack s)
67. {
68. this.s = s;
69. }
70.
71. public void run()
72. {
73. char ch;
74. for (int i = 0; i < 5; i++)
75. {
76. try
77. {
78. Thread.sleep((int) (Math.random() * 3000));
79. } catch (InterruptedException e) {
80. }
81. ch = s.pop(); // 从堆栈中读取字符
82. System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
83. }
84. }
85. }
86.
87. public class CommunicationDemo2
88. {
89. public static void main(String[] args)
90. {
91. SyncStack stack = new SyncStack();
92. // 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
93. Thread t1 = new Thread(new Producer(stack)); // 线程实例化
94. Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
95. t2.start(); // 线程启动
96. t1.start(); // 线程启动
97. }
98. }
// 例4.6.2 CommunicationDemo2.java
class SyncStack // 同步堆栈类，可以一次放入多个数据
{
private int index = 0; // 堆栈指针初始值为0
private char[] buffer = new char[5]; // 堆栈有5个字符的空间
public synchronized void push(char c) // 入栈同步方法
{
if (index == buffer.length) // 堆栈已满，不能入栈
{
try
{
this.wait(); // 等待出栈线程将数据出栈
} catch (InterruptedException e) {
}
}
buffer[index] = c; // 数据入栈
index++; // 指针加1，栈内空间减少
this.notify(); // 通知其他线程把数据出栈
}
public synchronized char pop() // 出栈同步方法
{
if (index == 0) // 堆栈无数据，不能出栈
{
try
{
this.wait(); // 等待入栈线程把数据入栈
} catch (InterruptedException e) {
}
}
this.notify(); // 通知其他线程入栈
index--; // 指针向下移动
return buffer[index]; // 数据出栈
}
}
class Producer implements Runnable // 生产者类
{
SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
public Producer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
s.push(ch); // 把字符入栈
System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
}
}
}
JAVA线程间通信问题
有很多现实问题要求不仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？
解决思路
在现实应用中，很多时候都需要让多个线程按照一定的次序来访问共享资源，例如，经典的生产者和消费者问题。这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可以将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。显然，这是一个同步问题，生产者和消费者共享同一资源，并且，生产者和消费者之间彼此依赖，互为条件向前推进。但是，该如何编写程序来解决这个问题呢？
传统的思路是利用循环检测的方式来实现，这种方式通过重复检查某一个特定条件是否成立来决定线程的推进顺序。比如，一旦生产者生产结束，它就继续利用循环检测来判断仓库中的产品是否被消费者消费，而消费者也是在消费结束后就会立即使用循环检测的方式来判断仓库中是否又放进产品。显然，这些操作是很耗费CPU资源的，不值得提倡。那么有没有更好的方法来解决这类问题呢？
首先，当线程在继续执行前需要等待一个条件方可继续执行时，仅有 synchronized 关键字是不够的。因为虽然synchronized关键字可以阻止并发更新同一个共享资源，实现了同步，但是它不能用来实现线程间的消息传递，也就是所谓的通信。而在处理此类问题的时候又必须遵循一种原则，即：对于生产者，在生产者没有生产之前，要通知消费者等待；在生产者生产之后，马上又通知消费者消费；对于消费者，在消费者消费之后，要通知生产者已经消费结束，需要继续生产新的产品以供消费。
其实，Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和 notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。
虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。
这些方法在Object类中声明的语法格式如下所示：
Java代码 收藏代码
1. final void wait() throws InterruptedException
2.
3. final void notify()
4.
5. final void notifyAll()
final void wait() throws InterruptedException
final void notify()
final void notifyAll()
其中，调用wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行态退出，进入等待队列，直到被再次唤醒。而调用notify() 方法可以唤醒等待队列中第一个等待同一共享资源的线程，并使该线程退出等待队列，进入可运行态。调用notifyAll()方法可以使所有正在等待队列中等待同一共享资源的线程从等待状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行。显然，利用这些方法就不必再循环检测共享资源的状态，而是在需要的时候直接唤醒等待队列中的线程就可以了。这样不但节省了宝贵的CPU资源，也提高了程序的效率。
由于wait()方法在声明的时候被声明为抛出InterruptedException异常，因此，在调用wait()方法时，需要将它放入 try…catch代码块中。此外，使用该方法时还需要把它放到一个同步代码段中，否则会出现如下异常：
Java代码 收藏代码
1. Java代码
2. "java.lang.IllegalMonitorStateException: current thread not owner"
3.
Java代码
"java.lang.IllegalMonitorStateException: current thread not owner"
这些方法是不是就可以实现线程间的通信了呢？下面将通过多线程同步的模型: 生产者和消费者问题来说明怎样通过程序解决多线程间的通信问题。
具体步骤
下面这个程序演示了多个线程之间进行通信的具体实现过程。程序中用到了4个类，其中ShareData类用来定义共享数据和同步方法。在同步方法中调用了wait()方法和notify()方法，并通过一个信号量来实现线程间的消息传递。
Java代码 收藏代码
1. Java代码
2. // 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
3.
4. class ShareData
5.
6. {
7. private char c;
8. private boolean isProduced = false; // 信号量
9. public synchronized void putShareChar(char c) // 同步方法putShareChar()
10. {
11. if (isProduced) // 如果产品还未消费，则生产者等待
12. {
13. try
14. {
15. wait(); // 生产者等待
16. } catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20. this.c = c;
21. isProduced = true; // 标记已经生产
22. notify(); // 通知消费者已经生产，可以消费
23. }
24.
25. public synchronized char getShareChar() // 同步方法getShareChar()
26. {
27. if (!isProduced) // 如果产品还未生产，则消费者等待
28. {
29. try
30. {
31. wait(); // 消费者等待
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. }
36. isProduced = false; // 标记已经消费
37. notify(); // 通知需要生产
38. return this.c;
39. }
40. }
41.
42. class Producer extends Thread // 生产者线程
43. {
44. private ShareData s;
45.
46. Producer(ShareData s)
47. {
48. this.s = s;
49. }
50.
51. public void run()
52. {
53. for (char ch = 'A'; ch <= 'D'; ch++)
54. {
55. try
56. {
57. Thread.sleep((int) (Math.random() * 3000));
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. }
61. s.putShareChar(ch); // 将产品放入仓库
62. System.out.println(ch + " is produced by Producer.");
63. }
64. }
65. }
66.
67. class Consumer extends Thread // 消费者线程
68. {
69. private ShareData s;
70.
71. Consumer(ShareData s)
72. {
73. this.s = s;
74. }
75.
76. public void run()
77. {
78. char ch;
79. do {
80. try
81. {
82. Thread.sleep((int) (Math.random() * 3000));
83. } catch (InterruptedException e) {
84. e.printStackTrace();
85. }
86. ch = s.getShareChar(); // 从仓库中取出产品
87. System.out.println(ch + " is consumed by Consumer. ");
88. } while (ch != 'D');
89. }
90. }
91.
92. class CommunicationDemo
93. {
94. public static void main(String[] args)
95. {
96. ShareData s = new ShareData();
97. new Consumer(s).start();
98. new Producer(s).start();
99. }
100. }
Java代码
// 例4.6.1 CommunicationDemo.java 描述：生产者和消费者之间的消息传递过程
class ShareData
{
private char c;
private boolean isProduced = false; // 信号量
public synchronized void putShareChar(char c) // 同步方法putShareChar()
{
if (isProduced) // 如果产品还未消费，则生产者等待
{
try
{
wait(); // 生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.c = c;
isProduced = true; // 标记已经生产
notify(); // 通知消费者已经生产，可以消费
}
public synchronized char getShareChar() // 同步方法getShareChar()
{
if (!isProduced) // 如果产品还未生产，则消费者等待
{
try
{
wait(); // 消费者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isProduced = false; // 标记已经消费
notify(); // 通知需要生产
return this.c;
}
}
class Producer extends Thread // 生产者线程
{
private ShareData s;
Producer(ShareData s)
{
this.s = s;
}
public void run()
{
for (char ch = 'A'; ch <= 'D'; ch++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
s.putShareChar(ch); // 将产品放入仓库
System.out.println(ch + " is produced by Producer.");
}
}
}
class Consumer extends Thread // 消费者线程
{
private ShareData s;
Consumer(ShareData s)
{
this.s = s;
}
public void run()
{
char ch;
do {
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
e.printStackTrace();
}
ch = s.getShareChar(); // 从仓库中取出产品
System.out.println(ch + " is consumed by Consumer. ");
} while (ch != 'D');
}
}
class CommunicationDemo
{
public static void main(String[] args)
{
ShareData s = new ShareData();
new Consumer(s).start();
new Producer(s).start();
}
}
上面的程序演示了生产者生产出A、B、C、D四个字符，消费者消费这四个字符的全过程
通过程序的运行结果可以看到，尽管在主方法中先启动了Consumer线程，但是，由于仓库中没有产品，因此，Consumer线程就会调用 wait()方法进入等待队列进行等待，直到Producer线程将产品生产出来并放进仓库，然后使用notify()方法将其唤醒。
由于在两个线程中都指定了一定的休眠时间，因此也可能出现这样的情况：生产者将产品生产出来放入仓库，并通知等待队列中的Consumer线程，然而，由于休眠时间过长，Consumer线程还没有打算消费产品，此时，Producer线程欲生产下一个产品，结果由于仓库中的产品没有被消费掉，故 Producer线程执行wait()方法进入等待队列等待，直到Consumer线程将仓库中的产品消费掉以后通过notify()方法去唤醒等待队列中的Producer线程为止。可见，两个线程之间除了必须保持同步之外，还要通过相互通信才能继续向前推进。
前面这个程序中，生产者一次只能生产一个产品，而消费者也只能一次消费一个产品。那么现实中也有这样的情况，生产者可以一次生产多个产品，只要仓库容量够大，就可以一直生产。而消费者也可以一次消费多个产品，直到仓库中没有产品为止。
但是，无论是生产产品到仓库，还是从仓库中消费，每一次都只能允许一个操作。显然，这也是个同步问题，只不过在这个问题中共享资源是一个资源池，可以存放多个资源。下面就以栈结构为例给出如何在这个问题中解决线程通信的程序代码。
Java代码 收藏代码
1. // 例4.6.2 CommunicationDemo2.java
2.
3. class SyncStack // 同步堆栈类，可以一次放入多个数据
4. {
5. private int index = 0; // 堆栈指针初始值为0
6. private char[] buffer = new char[5]; // 堆栈有5个字符的空间
7. public synchronized void push(char c) // 入栈同步方法
8. {
9. if (index == buffer.length) // 堆栈已满，不能入栈
10. {
11. try
12. {
13. this.wait(); // 等待出栈线程将数据出栈
14. } catch (InterruptedException e) {
15. }
16. }
17. buffer[index] = c; // 数据入栈
18. index++; // 指针加1，栈内空间减少
19. this.notify(); // 通知其他线程把数据出栈
20. }
21.
22. public synchronized char pop() // 出栈同步方法
23. {
24. if (index == 0) // 堆栈无数据，不能出栈
25. {
26. try
27. {
28. this.wait(); // 等待入栈线程把数据入栈
29. } catch (InterruptedException e) {
30. }
31. }
32. this.notify(); // 通知其他线程入栈
33. index--; // 指针向下移动
34. return buffer[index]; // 数据出栈
35. }
36. }
37.
38. class Producer implements Runnable // 生产者类
39. {
40. SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
41. public Producer(SyncStack s)
42. {
43. this.s = s;
44. }
45.
46. public void run()
47. {
48. char ch;
49. for (int i = 0; i < 5; i++)
50. {
51. try
52. {
53. Thread.sleep((int) (Math.random() * 1000));
54. } catch (InterruptedException e) {
55. }
56. ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
57. s.push(ch); // 把字符入栈
58. System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
59. }
60. }
61. }
62.
63. class Consumer implements Runnable // 消费者类
64. {
65. SyncStack s; // 消费者类获得的字符都来自同步堆栈
66. public Consumer(SyncStack s)
67. {
68. this.s = s;
69. }
70.
71. public void run()
72. {
73. char ch;
74. for (int i = 0; i < 5; i++)
75. {
76. try
77. {
78. Thread.sleep((int) (Math.random() * 3000));
79. } catch (InterruptedException e) {
80. }
81. ch = s.pop(); // 从堆栈中读取字符
82. System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
83. }
84. }
85. }
86.
87. public class CommunicationDemo2
88. {
89. public static void main(String[] args)
90. {
91. SyncStack stack = new SyncStack();
92. // 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
93. Thread t1 = new Thread(new Producer(stack)); // 线程实例化
94. Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
95. t2.start(); // 线程启动
96. t1.start(); // 线程启动
97. }
98. }
// 例4.6.2 CommunicationDemo2.java
class SyncStack // 同步堆栈类，可以一次放入多个数据
{
private int index = 0; // 堆栈指针初始值为0
private char[] buffer = new char[5]; // 堆栈有5个字符的空间
public synchronized void push(char c) // 入栈同步方法
{
if (index == buffer.length) // 堆栈已满，不能入栈
{
try
{
this.wait(); // 等待出栈线程将数据出栈
} catch (InterruptedException e) {
}
}
buffer[index] = c; // 数据入栈
index++; // 指针加1，栈内空间减少
this.notify(); // 通知其他线程把数据出栈
}
public synchronized char pop() // 出栈同步方法
{
if (index == 0) // 堆栈无数据，不能出栈
{
try
{
this.wait(); // 等待入栈线程把数据入栈
} catch (InterruptedException e) {
}
}
this.notify(); // 通知其他线程入栈
index--; // 指针向下移动
return buffer[index]; // 数据出栈
}
}
class Producer implements Runnable // 生产者类
{
SyncStack s; // 生产者类生成的字母都保存到同步堆栈中
public Producer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
ch = (char) (Math.random() * 26 + 'A'); // 随机产生5个字符
s.push(ch); // 把字符入栈
System.out.println("Push " + ch + " in Stack"); // 打印字符入栈
}
}
}
class Consumer implements Runnable // 消费者类
{
SyncStack s; // 消费者类获得的字符都来自同步堆栈
public Consumer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
}
ch = s.pop(); // 从堆栈中读取字符
System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
}
}
}
public class CommunicationDemo2
{
public static void main(String[] args)
{
SyncStack stack = new SyncStack();
// 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
Thread t1 = new Thread(new Producer(stack)); // 线程实例化
Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
t2.start(); // 线程启动
t1.start(); // 线程启动
}
}
程序中引入了一个堆栈数组buffer[]来模拟资源池，并使生产者类和消费者类都实现了Runnable接口，然后在主程序中通过前面介绍的方法创建两个共享同一堆栈资源的线程，并且有意先启动消费者线程，后启动生产者线程。请在阅读程序的时候仔细观察例4.6.1和本例的相似点以及区别之处，体会作者的用心。
由于是栈结构，所以符合后进先出原则。有兴趣的读者还可以用符合先进先出原则的队列结构来模拟线程间通信的过程，相信可以通过查阅相关的资料来解决这个问题，在这里就不再给出程序代码了，作为一个思考题供读者练习。
专家说明
本小节介绍了三个重要的方法：wait()、notify()和notifyAll()。使用它们可以高效率地完成多个线程间的通信问题，这样在通信问题上就不必再使用循环检测的方法来等待某个条件的发生，因为这种方法是极为浪费CPU资源的，当然这种情况也不是所期望的。在例4.6.1中，为了更好地通信，引入了一个专门用来传递信息的信号量。利用信号量来决定线程是否等待无疑是一种非常安全的操作，值得提倡。此外，在例4.6.2中引入了资源池作为共享资源，并解决了在这种情况下如何实现多线程之间的通信问题。希望读者能够举一反三，编写出解决更加复杂问题的程序。
专家指点
可以肯定的是，合理地使用wait()、notify()和notifyAll()方法确实能够很好地解决线程间通信的问题。但是，也应该了解到这些方法是更复杂的锁定、排队和并发性代码的构件。尤其是使用 notify()来代替notifyAll()时是有风险的。除非确实知道每一个线程正在做什么，否则最好使用notifyAll()。其实，在 JDK1.5中已经引入了一个新的包：java.util.concurrent 包，该包是一个被广泛使用的开放源码工具箱，里面都是有用的并发性实用程序。完全可以代替wait()和notify()方法用来编写自己的调度程序和锁。有关信息可以查阅相关资料，本书中不再赘述。
相关问题
Java提供了各种各样的输入输出流(stream)，使程序员能够很方便地对数据进行操作。其中，管道(pipe)流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读出数据。通过使用管道，达到实现多个线程间通信的目的。那么，如何创建和使用管道呢？
Java提供了两个特殊的专门用来处理管道的类，它们就是PipedInputStream类和PipedOutputStream类。
其中，PipedInputStream代表了数据在管道中的输出端，也就是线程从管道读出数据的一端；PipedOutputStream代表了数据在管道中的输入端，也就是线程向管道写入数据的一端，这两个类一起使用就可以创建出数据输入输出的管道流对象。
一旦创建了管道之后，就可以利用多线程的通信机制对磁盘中的文件通过管道进行数据的读写，从而使多线程的程序设计在实际应用中发挥更大的作用。
class Consumer implements Runnable // 消费者类
{
SyncStack s; // 消费者类获得的字符都来自同步堆栈
public Consumer(SyncStack s)
{
this.s = s;
}
public void run()
{
char ch;
for (int i = 0; i < 5; i++)
{
try
{
Thread.sleep((int) (Math.random() * 3000));
} catch (InterruptedException e) {
}
ch = s.pop(); // 从堆栈中读取字符
System.out.println("Pop " + ch + " from Stack"); // 打印字符出栈
}
}
}
public class CommunicationDemo2
{
public static void main(String[] args)
{
SyncStack stack = new SyncStack();
// 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
Thread t1 = new Thread(new Producer(stack)); // 线程实例化
Thread t2 = new Thread(new Consumer(stack)); // 线程实例化
t2.start(); // 线程启动
t1.start(); // 线程启动
}
}
程序中引入了一个堆栈数组buffer[]来模拟资源池，并使生产者类和消费者类都实现了Runnable接口，然后在主程序中通过前面介绍的方法创建两个共享同一堆栈资源的线程，并且有意先启动消费者线程，后启动生产者线程。请在阅读程序的时候仔细观察例4.6.1和本例的相似点以及区别之处，体会作者的用心。
由于是栈结构，所以符合后进先出原则。有兴趣的读者还可以用符合先进先出原则的队列结构来模拟线程间通信的过程，相信可以通过查阅相关的资料来解决这个问题，在这里就不再给出程序代码了，作为一个思考题供读者练习。
专家说明
本小节介绍了三个重要的方法：wait()、notify()和notifyAll()。使用它们可以高效率地完成多个线程间的通信问题，这样在通信问题上就不必再使用循环检测的方法来等待某个条件的发生，因为这种方法是极为浪费CPU资源的，当然这种情况也不是所期望的。在例4.6.1中，为了更好地通信，引入了一个专门用来传递信息的信号量。利用信号量来决定线程是否等待无疑是一种非常安全的操作，值得提倡。此外，在例4.6.2中引入了资源池作为共享资源，并解决了在这种情况下如何实现多线程之间的通信问题。希望读者能够举一反三，编写出解决更加复杂问题的程序。
专家指点
可以肯定的是，合理地使用wait()、notify()和notifyAll()方法确实能够很好地解决线程间通信的问题。但是，也应该了解到这些方法是更复杂的锁定、排队和并发性代码的构件。尤其是使用 notify()来代替notifyAll()时是有风险的。除非确实知道每一个线程正在做什么，否则最好使用notifyAll()。其实，在 JDK1.5中已经引入了一个新的包：java.util.concurrent 包，该包是一个被广泛使用的开放源码工具箱，里面都是有用的并发性实用程序。完全可以代替wait()和notify()方法用来编写自己的调度程序和锁。有关信息可以查阅相关资料，本书中不再赘述。
相关问题
Java提供了各种各样的输入输出流(stream)，使程序员能够很方便地对数据进行操作。其中，管道(pipe)流是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读出数据。通过使用管道，达到实现多个线程间通信的目的。那么，如何创建和使用管道呢？
Java提供了两个特殊的专门用来处理管道的类，它们就是PipedInputStream类和PipedOutputStream类。
其中，PipedInputStream代表了数据在管道中的输出端，也就是线程从管道读出数据的一端；PipedOutputStream代表了数据在管道中的输入端，也就是线程向管道写入数据的一端，这两个类一起使用就可以创建出数据输入输出的管道流对象。
一旦创建了管道之后，就可以利用多线程的通信机制对磁盘中的文件通过管道进行数据的读写，从而使多线程的程序设计在实际应用中发挥更大的作用。 [/size]
分享到：
发表评论
-
java hashmap深度剖析
2011-12-03 13:15 834在Java的世界里，无论类还是各种数据，其结构的处理是整个程序 ... -
内存优化的两个类：weakReference、 softReference
2011-12-03 11:42 1039如果你想写一个 Java 程序，观察某对象什么时候会被垃圾收集 ... -
java接口实现回调的功能
2011-11-02 13:35 1038在 Java 支持方法指针之前，Java 接口不能提供一种实现 ... -
调用java构造方法的总结
2011-10-18 09:28 7831.构造方法必须与定义它的类有完全相同的名字。构造方法没有返回 ... -
String compareTo 用法
2011-10-02 19:05 3338compareTo()的返回值是整型,它是先比较对应字符的大小 ... -
Java :使用Synchronized和Lock获得对象锁
2011-09-29 10:01 750在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。 1 ... -
Java的synchronized关键字：同步机制总结
2011-09-28 19:03 755JAVA中synchronized关键字能够作为函数的修饰符， ... -
回调（callback）方法
2011-09-14 10:46 1328你饿了,想吃饭,就一会去问你妈一声"开饭没有啊?&q ...
相关推荐
关于Java线程间通信-回调
使用wait()和notify()实现的生产者与消费者模型，可以了解如何使用wait()和notify()进行线程间通信。（上一次上传的代码有一个问题没有考虑到，这次修补了——CSDN没法撤销资源，只能再上传了）
内容概要：Java线程间通信的代码示例 适用人群：Java 使用场景：Java线程间交换数据 目标：通过本资源示例，深刻理解线程间通讯的基本原理和实现方法，解决工作中实际问题。
主要介绍了Java线程间通信不同步问题,结合实例形式分析了java线程间通信不同步问题的原理并模拟实现了线程间通信不同步情况下的异常输出,需要的朋友可以参考下
主要介绍了java线程间通信的通俗解释，介绍了线程通信中的几个相关概念，然后分享了线程通信的实现方式及代码示例，具有一定参考价值 ，需要的朋友可以了解下。
Java的多线程-线程间的通信.doc
下面小编就为大家带来一篇浅谈Java线程间通信之wait/notify。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java线程间通信 很有用的，可以用于安卓开发以及其他java的开发
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
在char03包里放置了Java线程间通信的知识的代码。内容如下： 等待/通知机制 join方法的使用 在char04包里放置了Java中Lock类的知识的代码，内容如下： Lock类 Lock类其他功能 Condition类 Condition类其他...
Java多线程--线程间的通信
1.线程同步 2.线程间通信 3.线程挂起、恢复和终止 demo演示
java多线程知识点，源代码案例，代码案例中包括如何创建线程，主线程，线程优先级，线程组，线程同步，死锁，线程间的通信知识点
利用线程间的通信主要是因为当多个线程同时对一个对象进行访问的时候，多个线程之间是一个协助的关系，举个例子就是今天要说的生产这和消费者模型。
下面小编就为大家带来一篇深入理解JAVA多线程之线程间的通信方式。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
彻底明白Java的多线程-线程间的通信.doc
结合大量实例，全面讲解Java多线程编程中的并发访问、线程间通信、锁等最难突破的核心技术与应用实践 Java多线程无处不在，如服务器、数据库、应用。多线程可以有效提升计算和处理效率，大大提升吞吐量和可伸缩性，...
某些情况下，程序要执行的操作需要满足一定的条件（下文统一将其称...一个线程因其保护条件未满足而被暂停的过程就被称为等待，一个线程使得其他线程的保护条件得以满足的时候唤醒那些被暂停的线程的过程就被称为通知。
主要介绍了Java编程线程间通信与信号量代码示例，具有一定借鉴价值，需要的朋友可以参考下。
生产者如果不释放对临界资源的占用权，那么 消费者就无法消费队列中的商品 ，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产...这种互相通信的过程就是线程间的协作。