Java多线程间通信-解决安全问题、等待唤醒机制

/*
1.增加一个知识点
一个类怎么在所有的类中，让其它类来共同修改它的数据呢？
可以用单例设计模式
可以用静态
可以在其它类中做一个构造函数，接受同一个对象，这样就可以实现对象

2.状态选择
可以用数字0 1 判断
可以用bool
注意变量的范围即可

3.加了同步后，还是有安全怎么办？
想前提！  1.  两个及以上线程（同步的）  2.操作公用资源  3.要用同一锁
*/

/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。

*/

/*
1.为什么会出现安全问题？
就是不满足前提呗

2.我们还没有了解到线程的本质
1.线程的执行时互相争抢执行权的
2.如果没有同步代码块的话，就会对数据进行胡乱修改，有可能修改到一半，另一个线程进来，有可能修改好几次，等等，甚至还会无视条件
3.即便有了同步代码块，也不能保证代码是按次序相互执行，因为，第一个线程执行完之后，还会参与下一次的争抢当中来，拥有相同的争抢概率
所以就出现同步中的不同步状况，这时候就要用到唤醒
4.其实程序就是一个逻辑判断问题，就是看有没有数据
*/

/*五种状态之一的等待
1.是Thread从上帝那里继承来的
2.而且这个函数是抛了异常的，根据异常的格式，要try和catch
3.唤醒也是继承上帝的
4.使用的时候，直接用对象点出来就可以
5.这样很容易区分，也造成为什么要把这两个函数写在上帝里面的原因，锁是任意类型的，什么对象都可以

*/
class Res                                   /*定义一个类，里面封装好数据成员，用来去调用*/
{
    String name;
    String sex;
    boolean flag = false;      /*用来判断是否已经存入数据，封装好用来调用*/
}

class Input implements Runnable
{
    private Res r ;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            synchronized(r)             /*只能让一个线程进来，而且输入的先进来，输出的就不给进了，这样就满足了前提，有两个线程，同一锁，公共资源*/
            {

if(r.flag)               /*真，冻结*/
                    try{r.wait();}catch(Exception e){}     /*线程池，等待线程都在线程池当中，唤醒的是什么，唤醒的都是线程池当中的线程*/
                if(x==0)
                {
                    r.name="mike";                    /*赋值*/
                    r.sex="man";
                }
                else
                {
                    r.name="丽丽";
                    r.sex = "女女女女女";
                }
                x = (x+1)%2;               /*转换性别*/
                r.flag = true;    
                r.notify();       /*有就唤醒，没有就不唤醒，按顺序来自然就不需要这个，唤醒的是另一个线程*/
            }
        }
    }
}

class Output implements Runnable
{
    private Res r ;            /*对象数据成员*/
    
    Output(Res r)
    {
        this.r = r;                  /*传递对象进来*/
    }
    public void run()
    {
        while(true)
        {
            synchronized(r)             /*放的是对象*/
            {
                if(!r.flag)
                    try{r.wait();}catch(Exception e){}
                System.out.println(r.name+"...."+r.sex);            /*删除*/
                r.flag = false;    
                r.notify();                                 /*唤醒输入线程*/
            }
        }
    }
}

class  InputOutputDemo
{
    public static void main(String[] args)
    {
        Res r = new Res();                     /*封装好的类，将会当作参数，传递给其它类*/

Input in = new Input(r);               /*实现多线程类的对象*/
        Output out = new Output(r);

Thread t1 = new Thread(in);          /*开启线程，把实现线程的对象放进来*/
        Thread t2 = new Thread(out);

t1.start();                  /*开启线程，调用run函数*/
        t2.start();
    }
}

//notifyAll();

/*
wait:
notify();
notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

*/

代码优化：
/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。

*/
class Res
{
    private String name;
    private String sex;
    private boolean flag = false;

public synchronized void set(String name,String sex)
    {
        if(flag)
            try{this.wait();}catch(Exception e){}             /*记住，加同步的是共同操作的数据，不是定义数据，是会变动的数据*/
        this.name = name;
        
        this.sex = sex;
        flag = true;
        this.notify();                                       /*this代表同步函数的锁，也代表当前对象*/
    }
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"........"+sex);
        flag = false;
        this.notify();
    }
}

class Input implements Runnable
{
    private Res r ;                 /*用来接收同一个对象*/
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            if(x==0)                
                r.set("mike","man");    /*这个函数已经是同步函数了*/            
            else    
                r.set("丽丽","女女女女女");                
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable
{
    private Res r ;
    
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();       /*不断输出*/
        }
    }
}

class  InputOutputDemo2
{
    public static void main(String[] args)
    {
        Res r = new Res();

new Thread(new Input(r)).start();            /*全部使用无名对象，优化代码*/
        new Thread(new Output(r)).start();
        /*
        Input in = new Input(r);
        Output out = new Output(r);

Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);

t1.start();
        t2.start();
        */
    }
}