thinking in java 05

- 日理万妓 2022-08-21 00:17 316阅读 0赞

线程之间的协作：

只能在同步方法或者同步控制块中调用wait() notify() notifyAll() 否则运行时抛出异常

线程调用sleep() yield()时 线程上的锁没有释放，调用wait()时 线程被挂起 锁释放

使用notify()而不是notifyAll()是一种优化

使用notify()的限制 ：1 .所有任务必须等待相同的条件

  1.    2. 当条件变化时，必须只有一个任务从中受益

notifyAll()因某个特定锁调用时，只能等待这个锁的任务才会被唤醒

而这个锁与底层锁有关。

具体代码如下：

  1. package Number_2103;
  3. import java.util.Timer;
  4. import java.util.TimerTask;
  5. import java.util.concurrent.ExecutorService;
  6. import java.util.concurrent.Executors;
  7. import java.util.concurrent.TimeUnit;
  9. /**
  10.  * notifyAll() 只能唤醒特定锁 wait()的线程
  11.  * 该特定锁与底层对象有关   ---->
  12.  * 
  13.  * @author he
  14.  *
  15.  */
  16. class Blocker {
  17.     synchronized void waitingforCall() {
  19.         try {
  20.             while (!Thread.interrupted()) {
  21.                 wait();
  22.                 System.out.println(Thread.currentThread().hashCode() + "----");
  23.             }
  25.         } catch (InterruptedException e) {
  26.             // TODO Auto-generated catch block
  27.             e.printStackTrace();
  28.         }
  30.     }
  32.     synchronized void prod() {
  33.         notify();
  34.     }
  36.     synchronized void prodAll() {
  37.         notifyAll();
  38.     }
  39. }
  41. class Task implements Runnable {
  42.     static Blocker b1;
  44.     public Task(Blocker b) {
  45.         b1 = b;
  47.     }
  49.     public synchronized void run() {
  50.         // TODO Auto-generated method stub
  51.         b1.waitingforCall();
  53.     }
  55. }
  57. class Task2 implements Runnable {
  58.     static Blocker b2;
  60.     public Task2(Blocker b) {
  61.         b2 = b;
  62.     }
  64.     public synchronized void run() {
  65.         // TODO Auto-generated method stub
  66.         b2.waitingforCall();
  67.     }
  68. }
  70. public class P707 {
  71.     public static void main(String[] args) throws Exception {
  72.         ExecutorService eService = Executors.newCachedThreadPool();
  73.         Blocker b = new Blocker();
  74.         Blocker b2=new Blocker();
  77.         eService.execute(new Task(b));
  78.         eService.execute(new Task2(b2));
  79.         Timer t = new Timer();
  80.         t.schedule(new TimerTask() {
  81.             boolean pro = true;
  83.             @Override
  84.             public void run() {
  85.                 if (pro) {
  86.                     Task.b1.prod();
  87.                     pro = false;
  88.                 } else {
  89.                     Task.b1.prodAll();
  90.                     pro = true;
  91.                 }
  93.             }
  94.         }, 400, 400);
  96.         TimeUnit.SECONDS.sleep(5);
  97.         ;
  98.         t.cancel();
  99.         System.out.println(" timer cancled");
  100.         TimeUnit.MICROSECONDS.sleep(500);
  101.         Task2.b2.prodAll();
  102.         TimeUnit.MICROSECONDS.sleep(5000);
  103.         System.out.println("Shutting down");
  104.         eService.shutdown();
  106.     }
  108. }

代码分析：public void run() {
if (pro) {
Task.b1.prod();
pro = false;
} else {
Task.b1.prodAll();
pro = true;
}

}

这段代码中交替调用Task中Blocker对象b1的prod(）方法和prodall()方法

但是

  1. Blocker b = new Blocker();
  2.         Blocker b2=new Blocker();
  5.         eService.execute(new Task(b));
  6.         eService.execute(new Task2(b2));

由于Task()中穿的Blocker对象不同，所以此时b1.prodall（）并不能唤醒task2对象

代码结果如下：

2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
2059770520——
timer cancled
1824109660——
Shutting down

-———————————————————————————————————

如果将代码

  1. Blocker b = new Blocker();
  2.         Blocker b2=new Blocker();
  5.         eService.execute(new Task(b));
  6.         eService.execute(new Task2(b2));

改为：

  1.             eService.execute(new Task(b));

eService.execute(new Task2(b));

代码结果如下：

2059770520——
2059770520——
1824109660——
2059770520——
2059770520——
1824109660——
2059770520——
2059770520——
1824109660——
2059770520——
2059770520——
1824109660——
2059770520——
2059770520——
1824109660——
2059770520——
2059770520——
1824109660——
timer cancled
1824109660——
2059770520——
Shutting down

-——————————————————————-

由于 task 和task2 中传的是相同的Blocker对象具有相同的底层锁

此时 此时b1.prodall（）能唤醒task2对象

task2.b2.prodall()也能唤醒task对象

使用同步队列进行同步控制 LinkedBlockingQueue 无界 ArrayBlockingQueue 有固定大小 

  1. package Number_2103;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.LinkedBlockingQueue;
  6. import java.util.concurrent.TimeUnit;
  8. import Number_2103.Toast.Status;
  10. /**
  11.  * 使用同步队列进行同步控制 LinkedBlockingQueue 无界 ArrayBlockingQueue 有固定大小
  12.  * 
  13.  * @author he
  14.  *
  15.  */
  17. class Toast {
  18.     public enum Status {
  19.         DRY, BUTTERED, JAMMED
  20.     }
  22.     private static Status status = Status.DRY;
  23.     private final int id;
  25.     public Toast(int id) {
  26.         this.id = id;
  27.     }
  29.     public void butter() {
  30.         status = Status.BUTTERED;
  31.     }
  33.     public void jam() {
  34.         status = Status.JAMMED;
  35.     }
  37.     public int getId() {
  38.         return id;
  39.     }
  41.     public static Status getStatus() {
  42.         return status;
  43.     }
  45.     @Override
  46.     public String toString() {
  47.         // TODO Auto-generated method stub
  48.         return "Toast" + id + ":" + status;
  49.     }
  51. }
  53. class ToastQueue extends LinkedBlockingQueue<Toast> {
  54. }
  56. class Toaster implements Runnable {
  57.     ToastQueue toastDry;
  58.     private int count = 0;
  60.     public Toaster(ToastQueue t) {
  61.         toastDry = t;
  62.     }
  64.     public void run() {
  65.         try {
  67.             while (!Thread.interrupted()) {
  69.                 Toast t = new Toast(count++);
  70.                 System.out.println(t);
  71.                 toastDry.put(t);
  72.             }
  74.         } catch (Exception e) {
  75.             // TODO: handle exception
  76.         }
  77.         System.out.println("Toaster off");
  78.     }
  80. }
  82. class ToastButter implements Runnable {
  83.     ToastQueue dryToast, butterToast;
  85.     public ToastButter(ToastQueue dry, ToastQueue butter) {
  86.         dryToast = dry;
  87.         butterToast = butter;
  88.     }
  90.     public void run() {
  91.         try {
  93.             while (!Thread.interrupted()) {
  94.                 // 获取并移除头部，在元素变得可用之前一直等待
  95.                 Toast t = dryToast.take();
  96.                 t.butter();
  97.                 System.out.println(t);
  98.                 butterToast.put(t);
  100.             }
  102.         } catch (Exception e) {
  103.             // TODO: handle exception
  104.         }
  105.         System.out.println("Butter  off");
  106.     }
  108. }
  110. class ToastJam implements Runnable {
  111.     ToastQueue butt, jam;
  113.     public ToastJam(ToastQueue buf, ToastQueue j) {
  114.         butt = buf;
  115.         jam = j;
  116.     }
  118.     public void run() {
  119.         try {
  120.             while (!Thread.interrupted()) {
  121.                 Toast t = butt.take();
  122.                 t.jam();
  123.                 System.out.println(t);
  124.                 jam.put(t);
  125.             }
  126.         } catch (Exception e) {
  127.             // TODO: handle exception
  128.         }
  129.         System.out.println("Jam  off");
  130.     }
  132. }
  134. class Eater implements Runnable {
  135.     private ToastQueue fin;
  136.     private int count = 0;
  138.     public Eater(ToastQueue t) {
  139.         fin = t;
  140.     }
  142.     public void run() {
  143.         try {
  144.             while (!Thread.interrupted()) {
  145.                 Toast t = fin.take();
  146.                 if (t.getId() != count++ || t.getStatus() != Status.JAMMED) {
  147.                     System.out.println("Error" + t);
  148.                     System.exit(0);
  149.                 }
  150.                 else{
  151.                     System.out.println("Chomp "+t);
  152.                 }
  154.             }
  155.         } catch (Exception e) {
  156.             // TODO: handle exception
  157.         }
  159.     }
  161. }
  163. public class P716 {
  165.     public static void main(String[] args) throws Exception {
  166.         ExecutorService eService = Executors.newCachedThreadPool();
  167.         ToastQueue dryQueue = new ToastQueue();
  168.         ToastQueue butterQueue = new ToastQueue();
  169.         ToastQueue jamQueue = new ToastQueue();
  171.         eService.execute(new Toaster(dryQueue));
  172.         eService.execute(new ToastButter(dryQueue, butterQueue));
  173.         eService.execute(new ToastJam(butterQueue, jamQueue));
  174.         eService.execute(new Eater(jamQueue));
  175.         TimeUnit.MILLISECONDS.sleep(1);
  176.         eService.shutdownNow();
  178.     }
  180. }

生产者与消费者：

  1. package Number_2103;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * P709 生产者与消费者
  9.  * 
  10.  * @author he
  11.  *
  12.  */
  14. class Meal {
  15.     private final int count;
  17.     public Meal(int count) {
  18.         this.count = count;
  19.     }
  21.     @Override
  22.     public String toString() {
  24.         return "Meal " + count;
  25.     }
  27. }
  29. class WaitPerson implements Runnable {
  30.     private Restaurant restaurant;
  32.     public WaitPerson(Restaurant r) {
  33.         restaurant = r;
  34.     }
  36.     public void run() {
  37.         try {
  38.             while (!Thread.interrupted()) {
  39.                 synchronized (this) {
  40.                     while (restaurant.meal == null) {
  41.                         wait();
  42.                     }
  43.                 }
  44.                 System.out.println("WaitPerson got:" + restaurant.meal);
  46.                 synchronized (restaurant.chef) {
  47.                     restaurant.meal = null;
  48.                     restaurant.chef.notifyAll();
  49.                 }
  51.             }
  53.         } catch (InterruptedException e) {
  54.             System.out.println("WaitPerson interruped");
  55.         }
  57.     }
  59. }
  61. class Chef implements Runnable {
  62.     private Restaurant restaurant;
  63.     private int count = 0;
  65.     public Chef(Restaurant r) {
  66.         restaurant = r;
  67.     }
  69.     public void run() {
  70.         try {
  71.             while (!Thread.interrupted()) {
  72.                 synchronized (this) {
  73.                     while (restaurant.meal != null) {
  74.                         wait();
  75.                     }
  76.                 }
  78.                 if (++count == 10) {
  79.                     System.out.println("停止出售");
  80.                     restaurant.eService.shutdownNow();
  81.                 }
  83.                 TimeUnit.MICROSECONDS.sleep(100);
  84.                 System.out.print("Order up");
  85.                 synchronized (restaurant.waitPerson) {
  86.                     restaurant.meal = new Meal(count);
  87.                     // 唤醒服务员线程
  88.                     restaurant.waitPerson.notifyAll();
  89.                 }
  90.             }
  92.         } catch (InterruptedException e) {
  93.             System.out.println("退出线程");
  94.         }
  96.     }
  97. }
  99. public class Restaurant {
  100.     Meal meal;
  101.     WaitPerson waitPerson = new WaitPerson(this);
  102.     Chef chef = new Chef(this);
  104.     ExecutorService eService = Executors.newCachedThreadPool();
  106.     public Restaurant() {
  107.         eService.execute(chef);
  108.         eService.execute(waitPerson);
  109.     }
  111.     public static void main(String[] args) {
  112.         new Restaurant();
  113.     }
  114. }

发表评论

表情：
评论列表 （有 0 条评论，316人围观）

还没有评论，来说两句吧...

相关阅读

    相关 thinking in java 04

    线程的状态：                                       1.新建（new）  ：分配了系统必要的资源，并执行了初始化，有资格获得CPU时间了

    青旅半醒青旅半醒/ 0 赞/ 204 阅读

    相关 Thinking in java(八)

    正则表达式 正则表达式符号介绍：正则表达式一般也需要使用字符串进行展示： 1、一般符号 x: 指的是普通字符，x代表的是未知数，代表着任何一个普通字符，举例x可以

    r囧r小猫r囧r小猫/ 0 赞/ 341 阅读

    相关 Think in Java——复用类

    复用类方法 Java复用代码的思路有两种： 组合：在新类中产生现有类的对象，再添加新的扩展成员与行为； 继承：新类继承自现有类，拥有现有类的全部特性。 组

    喜欢ヅ旅行喜欢ヅ旅行/ 0 赞/ 338 阅读

    相关 thinking in java 笔记

    1，多态，向上转型：解决的办法是后期绑定，它的含义就是在运行时根据对象的类型进行绑定。后期绑定也叫动态绑定或运行时绑定。 java中除了static方法和final方法，（p

    小灰灰小灰灰/ 0 赞/ 320 阅读

    相关 Think in Java——多态

    多态调用 1. 将 一个方法调用 和 一个方法主体 关联起来被称作绑定。绑定分为前期绑定与后期绑定，多态方法的具体调用依靠前期绑定是不行的，编译器不知道对象的具体类型无

    我不是女神ヾ我不是女神ヾ/ 0 赞/ 397 阅读