你的位置:首页 > Java教程

[Java教程]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();
        */
    }
}