Java学习day32

生产与消费者问题：假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者从仓库中取走产品；如果仓库中没有产品，生产者就将产品放入仓库，否则就停止生产等待；如果仓库中有产品，消费者就取走，否则就等待生产者生产

生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

Java提供了解决线程之间通信问题的方法：wait()　　//表示线程一直等待，知道其他线程通知，与sleep不同，会释放锁

　　　　　　　　　　　　　　　　　　　wait(long timeout)　　//指定等待的毫秒数

　　　　　　　　　　　　　　　　　　　notify()　　//唤醒一个处于等待状态的线程

　　　　　　　　　　　　　　　　　　　notifyAll()　　//唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

　　注意：以上均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegalMonitorStateException

解决办法：1.加入缓冲池，消费者和生产者都在缓冲池里操作

 1 package com.Cra2iTeT.Demo03;
 2
 3 public class test1 {
 4     public static void main(String[] args) {
 5         Container container = new Container();
 6         new Producer(container).start();
 7         new Consumer(container).start();
 8     }
 9 }
10
11 class Producer extends Thread {
12     Container container;
13
14     public Producer(Container container) {
15         this.container = container;
16     }
17
18     @Override
19     public void run() {
20         for (int i = 0; i < 100; i++) {
21             container.f1(new Product(i));
22             System.out.println("生产了" + i + "只鸡");
23         }
24     }
25 }
26
27 class Consumer extends Thread {
28     Container container;
29
30     public Consumer(Container container) {
31         this.container = container;
32     }
33
34     @Override
35     public void run() {
36         for (int i = 0; i < 100; i++) {
37             System.out.println("消费了" + container.f2().id + "只鸡");
38         }
39     }
40 }
41
42 class Product {
43     int id;
44     public Product(int id) {
45         this.id = id;
46     }
47 }
48
49 class Container {
50     Product[] products = new Product[100];
51     int count = 0;
52
53     public synchronized void f1(Product product) {
54         if (count == 10) {
55             try {
56                 this.wait();
57             } catch (InterruptedException e) {
58                 e.printStackTrace();
59             }
60         }
61         products[count] = product;
62         count++;
63         this.notifyAll();
64     }
65
66     public synchronized Product f2() {
67         if (count == 0) {
68             try {
69                 this.wait();
70             } catch (InterruptedException e) {
71                 // TODO Auto-generated catch block
72                 e.printStackTrace();
73             }
74         }
75         count--;
76         Product product = products[count];
77         this.notifyAll();
78         return product;
79     }
80 }

2.加入信号标识，指定信号标识下由指定的线程操作

 1 package com.Cra2iTeT.Demo03;
 2
 3 public class test2 {
 4     public static void main(String[] args) {
 5         TV tv = new TV();
 6         new Player(tv).start();
 7         new Watcher(tv).start();
 8     }
 9 }
10
11 class Player extends Thread {
12     TV tv;
13
14     public Player(TV tv) {
15         this.tv = tv;
16     }
17
18     @Override
19     public void run() {
20         for (int i = 0; i < 20; i++) {
21             if (i % 2 == 0) {
22                 this.tv.play("青海摇");
23             } else {
24                 this.tv.play("西安摇");
25             }
26         }
27     }
28 }
29
30 class Watcher extends Thread {
31     TV tv;
32
33     public Watcher(TV tv) {
34         this.tv = tv;
35     }
36
37     @Override
38     public void run() {
39         for (int i = 0; i < 20; i++) {
40             tv.watch();
41         }
42     }
43 }
44
45 class TV {
46     String voice;
47     boolean flag = true;
48
49     public synchronized void play(String voice) {
50         if (!flag) {
51             try {
52                 this.wait();
53             } catch (InterruptedException e) {
54                 e.printStackTrace();
55             }
56         }
57         System.out.println("演员表演了：" + voice);
58         this.notifyAll();
59         this.voice = voice;
60         this.flag = !this.flag;
61     }
62
63     public synchronized void watch() {
64         if (flag) {
65             try {
66                 this.wait();
67             } catch (InterruptedException e) {
68                 e.printStackTrace();
69             }
70         }
71         System.out.println("观看了：" + voice);
72         this.notifyAll();
73         this.flag = !this.flag;
74     }
75
76 }

明天学习线程池，总结多线程的学习过程