线程间的通信--等待唤醒机制

Posted 2020-10-22

1.多个线程操作相同的资源，但是操作动作不同，所以存在安全问题
例如：

public class Test {
    public static void main(String[] args) {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);

        Thread tin = new Thread(in);
        Thread tout = new Thread(out);

        tin.start();
        tout.start();
    }
}
/**
 * 两个线程共同的资源
 * @author WangShuang
 *
 */
class Resource{
    private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}
/**
 * 存资源的线程
 * @author WangShuang
 *
 */
class Input implements Runnable {
     private Resource resource;
    public Input(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        int x =0;
        while(true){
            synchronized (new Object()) {
                if(x==0){
                    resource.setName("张三");
                    resource.setSex("男");
                }else{
                    resource.setName("lili");
                    resource.setSex("女女女");
                }
                x=(x+1)%2;
            }
        }
    }
}
/**
 * 
 * @author 取资源的线程
 *
 */
class Output implements  Runnable {
    private Resource resource;
    public Output(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        while(true){
            synchronized (new Object()) {
                System.out.println(resource.getName()+"..."+resource.getSex());
            }

        }
    }
}

运行结果：
张三...男
张三...女女女
张三...男
张三...男
张三...女女女
lili...男

发生上述问题的原因：当output取线程时，output还没取完，例如只get到了name张三，cpu的执行权就被input夺走，执行了两个setlili 女,当output再次取线程是sex已经变成了女，所以出

现了 张三。。。女的现象
添加了同步也不管用，那么就应该思考同步的前提 是不是两个或两个以上的线程操作共享资源，是不是同一个锁对象，很明显没有满足

2.现在更改代码用同一个锁

public class Test {
    public static void main(String[] args) {
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);

        Thread tin = new Thread(in);
        Thread tout = new Thread(out);

        tin.start();
        tout.start();
    }
}
/**
 * 两个线程共同的资源
 * @author WangShuang
 *
 */
class Resource{
    private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}
/**
 * 存资源的线程
 * @author WangShuang
 *
 */
class Input implements Runnable {
     private Resource resource;
    public Input(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        int x =0;
        while(true){
            synchronized (resource) {
                if(x==0){
                    resource.setName("张三");
                    resource.setSex("男");
                }else{
                    resource.setName("lili");
                    resource.setSex("女女女");
                }
                x=(x+1)%2;
            }
        }
    }
}
/**
 * 
 * @author 取资源的线程
 *
 */
class Output implements  Runnable {
    private Resource resource;
    public Output(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        while(true){
            synchronized (resource) {
                System.out.println(resource.getName()+"..."+resource.getSex());
            }

        }
    }
}

运行结果
张三...男
张三...男
张三...男
张三...男
张三...男
张三...男
张三...男
张三...男
张三...男
张三...男
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
lili...女女女
虽然已经解决了张三。。。女和lili...男的问题，但是出现的大片的张三...男和大片的lili...女，这是为什么呢

当tin线程获得cpu的执行权后，执行了setName和setSext方法，cpu的执行权依然在tin线程手里，又一次执行了setName和setSext方法，覆盖了之前的setName和setSex方法，之后的同理。。。。。，那么又该如何实现存一个取一个呢？java的多线程中存在等待唤醒机制，代码如下

public class Test1 {
    public static void main(String[] args) {
        Resource1 r = new Resource1();
        Input1 input = new Input1(r);
        Output1 output = new Output1(r);
        new Thread(input).start();
        new Thread(input).start();
        new Thread(output).start();
        new Thread(output).start();

    }
}
/**
 * 两个线程共同的资源
 * @author WangShuang
 *
 */
class Resource1{
    private String name;
    private String sex;
    private int count;
    private boolean flag;//添加一个标记用来表示Resource中的资源是否为空（Input以后代表存入不为空，Output以后代表取出为空）
    public  String getOutput() {
        System.out.println(Thread.currentThread().getName()+"消费了一个"+sex+"---------------"+name);
        return name+"---"+sex;
    }
    public  void setInput(String name,String sex) {
        this.name = name+count++;
        this.sex = sex;
        System.out.println(Thread.currentThread().getName()+"生产了一个"+this.sex+"---"+this.name);
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
/**
 * 存资源的线程
 * @author WangShuang
 *
 */
class Input1 implements Runnable {
     private Resource1 resource;
    public Input1(Resource1 resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        int x =0;
        while(true){
            synchronized (resource) {
                if(resource.isFlag()){//如果flag是真，代码资源库中的资源还没有被取走，此时该线程应该放弃cpu的执行权，并把另一个线程叫醒
                    try {resource.wait();} catch (InterruptedException e) {e.printStackTrace();}
                }
                try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}//此处的线程等待是为了方便看运行结果
                if(x==0){
                    resource.setInput("张三","男");
                }else{
                    resource.setInput("lili","女");
                }
                x=(x+1)%2;
                resource.setFlag(true);
                resource.notify();
            }
        }
    }
}
/**
 * 
 * @author 取资源的线程
 *
 */
class Output1 implements  Runnable {
    private Resource1 resource;
    public Output1(Resource1 resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        while(true){
            synchronized (resource) {
                if(!resource.isFlag()){//如果flag是真，代码资源库中的资源还没有被取走，此时该线程应该放弃cpu的执行权，并把另一个线程叫醒
                    try {resource.wait();} catch (InterruptedException e) {e.printStackTrace();}
                }
                try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}//此处的线程等待是为了方便看运行结果
                resource.getOutput();
                resource.setFlag(false);
                resource.notify();
            }
        }
    }
}

运行结果如下：
Thread-0生产了一个男---张三0
Thread-3消费了一个男---------------张三0
Thread-1生产了一个男---张三1
Thread-2消费了一个男---------------张三1
Thread-1生产了一个女---lili2
Thread-3消费了一个女---------------lili2
Thread-0生产了一个女---lili3
Thread-3消费了一个女---------------lili3
Thread-0生产了一个男---张三4
Thread-3消费了一个男---------------张三4
Thread-1生产了一个男---张三5
Thread-2消费了一个男---------------张三5
Thread-1生产了一个女---lili6
Thread-3消费了一个女---------------lili6
Thread-0生产了一个女---lili7
Thread-3消费了一个女---------------lili7
Thread-0生产了一个男---张三8
Thread-3消费了一个男---------------张三8
Thread-0生产了一个女---lili9
Thread-3消费了一个女---------------lili9
Thread-0生产了一个男---张三10
Thread-2消费了一个男---------------张三10
Thread-0生产了一个女---lili11
Thread-1生产了一个男---张三12
Thread-0生产了一个男---张三13
Thread-1生产了一个女---lili14
Thread-0生产了一个女---lili15
Thread-2消费了一个女---------------lili15
Thread-3消费了一个女---------------lili15
Thread-1生产了一个男---张三16
Thread-2消费了一个男---------------张三16
Thread-3消费了一个男---------------张三16
Thread-1生产了一个女---lili17

出现了生产一个，消费2个的状态，那么这是为什么呢？

首先明白一件事：不具备执行资格的线程存在于内存中的线程池中，唤醒的线程的顺序，是谁先被等待，谁先被唤醒

当Thread-0获得cpu的执行权时，先判断资源是否为空，是开始生产资源，然后把判断资源是否为空的标记flag,设置为true,唤醒一个线程，Thread-0继续拥有cpu的执行权，先判断资源是否为空，不是空，wait()等待。然后Thread-1获得cpu的执行权，先判断资源是否为空，不是空，wait()等待。然后Thread-2获得cpu的执行权，先判断资源是否为空，不是空，取出资源，然后flag为false,唤醒一个线程,然后Thread-3开始执行，先判断资源是否为空，是空，wait（）等待，然后Thread-0获得cpu的执行权，上次Thread-0失去cpu的执行权时是通过resource.wait(),接着继续运行，生产资源，设置flag为true,唤醒一个线程，Thread-1获得cpu的执行权，上次Thread-1失去cpu的执行权时是通过resource.wait(),接着继续运行，生产资源，因此产生了生产两个资源的现象，设置flag为true,唤醒一个线程，然后Thread-2获得cpu的执行权，因为上次失去cpu的执行权是在resource.wait(),所以继续执行，不用判断资源是否为空，取出资源，然后flag为false,唤醒一个线程,然后Thread-3开始执行，因为上次失去cpu的执行权是在resource.wait(),所以继续执行，不用判断资源是否为空，取出资源，因此产生了消费两个相同资源的现象
注意现在的线程顺序是我自己本人想象出来的cpu的执行顺，cpu的执行顺序是随机的，所以各种现象都能解释的通，例如生产了两个，消费了一个，生产一个消费两个，生产两个不一样的，消费2个一样的（上述解释）等等，那么这个问题该如何解决呢？

产生上述问题的原因是因为，没有判断标记，那么
把判断资源是否为空的地方if(resource.getFlag())改成while(resource.getFlag())，这样就可以循环的判断标记了，当我们再次运行程序时，会发现Thread-0,Thread-1,Thread-2,Thread-3,全部等待的状态，产生这种现象的原因，自己按照代码的执行顺序自己理一遍就明白了，那么又该怎么办呢？

唤醒时，不要只唤醒一个线程，全部都唤醒好了notifyAll（）

下面的代码是最后的并且简化后的代码

public class Test {
    public static void main(String[] args) {
        Resource r = new Resource();
        Input input = new Input(r);
        Output output = new Output(r);
        new Thread(input).start();
        new Thread(input).start();
        new Thread(output).start();
        new Thread(output).start();

    }
}
/**
 * 两个线程共同的资源
 * @author WangShuang
 *
 */
class Resource{
    private String name;
    private String sex;
    private int count;
    private boolean flag;//添加一个标记用来表示Resource中的资源是否为空（Input以后代表存入不为空，Output以后代表取出为空）
    public synchronized String getOutput() {
        while(flag){//如果flag是真，代码资源库中的资源还没有被取走，此时该线程应该放弃cpu的执行权，并把另一个线程叫醒
            try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}
        }
        System.out.println(Thread.currentThread().getName()+"消费了一个"+sex+"---------------"+name);
        flag=true;
        this.notifyAll();
        return name+"---"+sex;

    }
    public synchronized void setInput(String name,String sex) {
        while(!flag){//如果flag是假，代码资源库中的资源已经被取走，此时该线程应该放弃cpu的执行权，并把另一个线程叫醒
            try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}
        }
        this.name = name+count++;
        this.sex = sex;
        System.out.println(Thread.currentThread().getName()+"生产了一个"+this.sex+"---"+this.name);
        flag=false;
        this.notifyAll();
    }

}
/**
 * 存资源的线程
 * @author WangShuang
 *
 */
class Input implements Runnable {
     private Resource resource;
    public Input(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        int x =0;
        while(true){
                if(x==0){
                    resource.setInput("张三","男");
                }else{
                    resource.setInput("lili","女");
                }
                x=(x+1)%2;
        }
    }
}
/**
 * 
 * @author 取资源的线程
 *
 */
class Output implements  Runnable {
    private Resource resource;
    public Output(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        while(true){
                resource.getOutput();
        }
    }
}