1 package Thread;
2
3 /**
4 * 线程之生产者消费者问题
5 * 生产者消费者问题是研究多线程程序时绕不开的问题，它的描述是有一块生产者和消费者共享的有界缓冲区，
生产者往缓冲区放入产品，消费者从缓冲区取走产品，这个过程可以无休止的执行，
不能因缓冲区满生产者放不进产品而终止，也不能因缓冲区空消费者无产品可取而终止
6 * @author ZolRa
7 *
8 */
9 public class ProducerAndConsumer {
10
11 public static void main(String[] args) {
12 SyncStack stack = new SyncStack();
13 Consumer p = new Consumer(stack);
14 Producer c = new Producer(stack);
15 new Thread(p).start();
16 new Thread(c).start();
17 }
18 }
19
20 /**
21 * 生产者
22 */
23 class Producer implements Runnable {
24 private SyncStack stack;
25
26 public Producer(SyncStack stack) {
27 this.stack = stack;
28 }
29
30 public void run() {
31 for (int i = 0; i < stack.pro().length; i++) {
32 String product = "产品" + i;
33 stack.push(product);
34 System.out.println("生产了: " + product);
35 try {
36 Thread.sleep(200);
37 } catch (InterruptedException e) {
38 e.printStackTrace();
39 }
40 }
41 }
42 }
43
44 /**
45 * 消费者
46 */
47 class Consumer implements Runnable {
48 private SyncStack stack;
49
50 public Consumer(SyncStack stack) {
51 this.stack = stack;
52 }
53
54 public void run() {
55 for (int i = 0; i < stack.pro().length; i++) {
56 String product = stack.pop();
57 System.out.println("消费了: " + product);
58 try {
59 Thread.sleep(1000);
60 } catch (InterruptedException e) {
61 e.printStackTrace();
62 }
63 }
64 }
65 }
66
67 class SyncStack {
68 private String[] str = new String[10];
69 private int index;
70
71 public synchronized void push(String sst) {
72 if (index == sst.length()) {
73 try {
74 wait();
75 } catch (InterruptedException e) {
76 e.printStackTrace();
77 }
78 }
79 this.notify();
80 str[index] = sst;
81 index++;
82 }
83
84 public synchronized String pop() {
85 if (index == 0) {
86 try {
87 wait();
88 } catch (InterruptedException e) {
89 e.printStackTrace();
90 }
91 }
92 notify();
93 index--;
94 String product = str[index];
95 return product;
96 }
97
98 public String[] pro() {
99 return str;
100 }
101 }
