并发编程 - wait和notifyAll

并发编程之枪械争夺

需求如下图:狙击手们和备弹手们同时争抢一把枪,枪同时只能被一人持有,且备弹容量上限为20。狙击手则使用枪械开枪子弹 -1,备弹手则给枪械上子弹 +1.

并发编程 - wait和notifyAll_第1张图片

问题分析:

    基于面向对象的编程思想,我们首先需要对三者进行抽象,需要创建以下三种类型。

  1. 创建枪械的类,枪械有shot和put方法,有枪械名称和子弹容量等属性。
  2. 创建狙击手类,由于我们是多线程编程,则实现runnable接口,在run方法中使用无限循环调用shot。
  3. 创建备弹手类,实现runnable接口,在run方法中使用无限循环调用put方法。

   在《Effective Java》中,对wait()、notify()、notifyAll()有所描述,作者认为wait()和notifyAll()是组合使用的,结合实际情况来看,确实是这样。如果使用notify()只唤醒一个线程,但是该线程却没有达到获取锁的条件,调用了wait()此时则会发生死锁的情况。

    wait()使用范式:

        while(不满足条件){

              wait();

        }

    notifyAll()使用范式:

       同步代码块,执行结束的最后一行语句,释放锁之前唤醒其他争抢这把锁的线程。

    

    synchronized同步锁使用方式

  1. 同步代码块
  2. 同步方法

    synchronized锁的是什么呢?

并发编程 - wait和notifyAll_第2张图片

    synchronized使用时需要注意以下几点:

  1. synchronized锁要设计好锁的粒度,减少资源的损耗。
  2. synchronized锁声明的方法上,在方法取的方法钱有ANS_SYCHRONIZED标识。
  3. synchronized代码块,则反编译会有monitor enter 和monitor exit方法作为锁开始和结束。jvm实现。
  4. synchronized是可重入锁。
  5. synchronized锁代码区间若抛出异常则释放锁。
  6. synchronized锁静态方法其实锁的是静态方法所属的类对象。
  7. synchronized锁普通方法锁的是这个类当前的实例对象。
  8. 一个类中多个方法、synchronized锁不同的对象,不争夺同一把锁的方法可以并行执行。

代码编写


public class Weapon {


    public static void main(String[] args) {
        GoldAKGun akGun = new GoldAKGun("黄金AK",10);
        new Thread(new Sniper(akGun),"狙击手->顺溜").start();
        new Thread(new Sniper(akGun),"狙击手->二嘎").start();
        //new Thread(new Deputy(akGun),"备弹手->二雷").start();
        new Thread(new Deputy(akGun),"备弹手->二毛").start();
        new Thread(new Deputy(akGun),"备弹手->铁蛋").start();
        new Thread(new Deputy(akGun),"备弹手->大柱").start();
    }


    public static class GoldAKGun{
        private String gunName = "AK";    //默认名字AK
        private Integer bollet = 0;     //默认备弹 0 发

        public GoldAKGun(String gunName, Integer bollet) {
            this.gunName = gunName;
            this.bollet = bollet;
        }

        public synchronized void putBollet(String name){
            try {
                while (bollet>=20){
                    System.out.println(name + "->发现["+ gunName +"]的子弹是满的 !");
                    this.wait();
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            bollet++;
            System.out.println(name + "->成功拿起["+ gunName +"]装入一枚子弹,当前子弹数目:" + bollet);
            this.notifyAll();
        }

        public synchronized void shotGirld(String name){
            try {
                while (bollet<=0){
                    System.out.println(name + "->发现["+ gunName +"]的弹夹是空的 !");
                    this.wait();
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            bollet--;
            System.out.println(name + "->扣动["+ gunName +"]板机,打了个鸟儿,当前子弹数目:" + bollet);
            this.notifyAll();
        }

    }


    public static class Sniper implements Runnable{

        GoldAKGun ak47;

        public Sniper(GoldAKGun ak47){
            this.ak47 = ak47;
        }

        @Override
        public void run(){
            for (;;) {
                sleep(500);
                ak47.shotGirld(Thread.currentThread().getName());
            }
        }
    }

    public static class Deputy implements Runnable{

        GoldAKGun ak47;

        public Deputy(GoldAKGun ak47){
            this.ak47 = ak47;
        }

        @Override
        public void run(){
            for (;;) {
                sleep(1000);
                ak47.putBollet(Thread.currentThread().getName());
            }
        }
    }

    public static void sleep(Integer millis){
        try {
            Thread.sleep(millis);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

总结描述

    synchronized、wait、notifyAll在常用的java开发框架中,多次出现,需要深入的研究一下。

你可能感兴趣的:(Java并发编程)