多线程2--毕向东基础视频教程学习笔记

Day12多线程：

1.线程间通信-示例代码

2.线程间通信-解决安全问题

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

4.线程间通信-代码优化

5.线程间通信-生产者消费者

 

 

1.线程间通信-示例代码

线程间通信：

其实就是多个线程在操作同一个资源，

但操作的动作不同。

示例代码：

class Res
 2 {
 3     String name;
 4     String sex;
 5     
 6 }
 7 class Input implements Runnable
 8 {
 9     int x=0;
10     private Res r;
11     public Input(Res r)
12     {
13         this.r=r;
14 
15     }
16     public void run()
17     {
18         while(true)
19         {
20             if(x==0)
21         {
22             r.name="Mike";
23             r.sex="man";
24         }
25         else
26         {
27             r.name="黎黎";
28             r.sex="女女女";
29             
30         }
31         x=(x+1)%2;
32 
33         }
34     
35 
36     }
37 }
38 class Output implements Runnable
39 {
40     private Res r;
41     public Output(Res r)
42     {
43         this.r=r;
44     }
45     public void run()
46     {
47         while(true)
48         {
49             System.out.println(r.name+"---"+r.sex);
50 
51         }
52 
53     }
54 }
55 public class InputOutputDemo
56 {
57     public static void main(String[] args)
58     {
59         Res r=new Res();
60         Output out=new Output(r);
61         Input in=new Input(r);
62 
63         Thread t1=new Thread(in);
64         Thread t2=new Thread(out);
65 
66         t1.start();
67         t2.start();
68     }
69 }

 

运行：

出现了错误的输出。

 

2.线程间通信-解决安全问题 

解决方法：

从两个方面考虑：

1.是否是多线程

2.是否用同一把锁。

改动后：

class Res
{
    String name;
    String sex;
    
}
class Input implements Runnable
{
    int x=0;
    private Res r;
    public Input(Res r)
    {
        this.r=r;

    }
    public void run()
    {
        while(true)
        {
                        //添加同步代码块，使用对象r作为锁

            synchronized(r)
            {
                if(x==0)
        {
            r.name="Mike";
            r.sex="man";
        }
        else
        {
            r.name="黎黎";
            r.sex="女女女";
            
        }

            }
            
        x=(x+1)%2;

        }
    

    }
}
class Output implements Runnable
{
    private Res r;
    public Output(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
                        //添加同步代码块，使用对象r作为锁
            synchronized(r)
            {
                System.out.println(r.name+"---"+r.sex);

            }
            

        }

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

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

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

运行：

不再有错误的输出，但是输出显示大片大片的男，大片大片的女。 

 

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

要实现男女交替输出的效果，要用到wait和notify方法。

wait（）

notify（）

notifyAll（）

都是用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中

只有同步才具有锁。

 

为什么这些操作线程的方法要定义在Object中呢？

因为这些方法在操作同步中的线程时，都必须标识它们所操作的线程持有的锁，

只有一个锁上的等待线程，可以被同一个锁上的notify唤醒。

不可以对不同锁上的线程进行唤醒。

 

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

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

修改后：

class Res
{
    String name;
    String sex;
    //定义布尔型标志位
    boolean flag=false;
    
}
class Input implements Runnable
{
    int x=0;
    private Res r;
    public Input(Res r)
    {
        this.r=r;

    }
    public void run()
    {
        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="女女女";
            
        }
        //改变flag值
        r.flag=true;
        //唤醒
        r.notify();

            }
            
        x=(x+1)%2;

        }
    

    }
}
class Output implements Runnable
{
    private Res r;
    public 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();

            }
            

        }

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

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

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

 

运行：

 

4.线程间通信-代码优化

数据私有化，通过方法访问。

优化后代码：

class Res
{
    //数据成员设置为私有
    private String name;
    private String sex;
    //定义布尔型标志位
    private boolean flag=false;
    
    //定义set、get同步方法
    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();
    }
    public synchronized void get()
    {
        if(!flag)
                {try{this.wait();}catch(Exception e){}}
        System.out.println(name+"---"+sex);

        flag=false;
        this.notify();
    }
    
}
class Input implements Runnable
{
    int x=0;
    private Res r;
    public Input(Res r)
    {
        this.r=r;

    }
    public void run()
    {
        while(true)
        {
                if(x==0)
          {
            //调用set方法
            r.set("Mike","man");
          }
           else
         {
            r.set("黎黎","女女女");
            
         }
        x=(x+1)%2;
        }
    

    }
}
class Output implements Runnable
{
    private Res r;
    public Output(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            //调用get方法
                r.get();
        }

    }
}
public class InputOutputDemo
{
    public static void main(String[] args)
    {
        Res r=new Res();
        //简化
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();

    
    }
}

 

5.线程间通信-生产者消费者

当有多个生产者，多个消费者时，必须循环判断标记，以避免产生生产2个，只消费了一个或类似的情况；

并且使用notifyAll方法，以避免出现所有线程都在等待的情况。

class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;

    public synchronized void set(String _name)
    {
        while(flag)
        {
            try{wait();}catch(Exception e){}
        }
        name=_name+"--"+count++;
        System.out.println(Thread.currentThread().getName()+"--生产者"+name);
        flag=true;
        notifyAll();

    }
    public synchronized void get()
    {
        while(!flag)
        {
            try{wait();}catch(Exception e){}
        }
        System.out.println(Thread.currentThread().getName()+"--------消费者"+name);
        flag=false;
        notifyAll();

    }
}
class Producer implements Runnable
{
    private Resource r=new Resource();
    public Producer(Resource r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.set("商品");
        }
    }
}
class Consumer implements Runnable
{
    private Resource r=new Resource();
    public Consumer(Resource r)
    {
        this.r=r;
    }
    public void run()
    {
        while(true)
        {
            r.get();
        }
    }
}
public class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Resource r=new Resource();

        Producer pro=new Producer(r);
        Consumer con=new Consumer(r);

        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

运行：