Java基础--多线程【线程间通信】

字数统计: 2.6k字   |   阅读时长: 10分

一、什么是线程通信

不同种类的线程（消费类、生产类）在处理同一个资源时，需要线程之间进行配合， 避免对同一共享变量的争夺，来实现线程之间对同一个变量的使用或操作。

（可以简单理解为：不同种类的线程针对统一资源的操作）

于是，Java引出了等待唤醒机制（也称为线程间的通信）：就是在一个线程进行了规定操作后，就进入等待状态（wait）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify）。

二、为什么需要线程通信

CPU的执行权是线程间随机抢占的，因此多个线程并发执行时, 当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行时，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

三、如何实现线程通信

Java为我们提供了以下方法来实现线程间的通信：

1
void wait()

线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll()方法），这样它才能重新获得锁的拥有权和恢复执行。

注意：要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。

1
void notify()

notify()方法会唤醒在此对象监视器上等待的单个线程，即：会唤醒一个等待当前对象的锁的线程。

1
void notifyAll()

notifyAll（）方法会唤醒在此对象监视器上等待的所有线程。
补充：细心的小伙伴可能已经发现了，这三个方法不就是Object里面的方法么。可是线程相关的方法不更应该在Thread类中吗？
怎么会定义在Object类中呢？
其实这是因为，所有的这些方法在使用时都是必须通过锁对象来调用的，但是我们在使用同步代码块时，是可以使用任意锁对象的。因此，只有将这些方法定义在Object类中才能满足方法呀！

四、实现线程通信的案例

我们可能都听说过，生产者-消费者模式是最好体现线程通信的例子。因此，接下来就让我们敲一个关于生产者和消费者的简单的小demo，来演示一下线程的通信：

（一）生产与消费面包（单生产、单消费）
资源类(面包类)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class Breads {
    
    //面包的id
    private int bid;
    //面包的个数
    private int num;
    
    //生产面包的方法
    public synchronized void produc(){
        //当面包的数量不为0时，该方法处于等待状态
        if(0 != num){
            try {
                wait();//等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当面包数量为0时，那么就开始生产面包了
        num  =  num +1;//数量加1
        bid = bid + 1 ;//id当然也得加1
        String threadname = Thread.currentThread().getName();
        System.out.println(threadname+"生产了一个编号为"+bid+"的面包！");
        notify();//当执行完后，去唤醒其他处于等待的线程
    }
    
    
    //消费面包的方法
    public synchronized void consume(){
        //当面包的数量为0时，该方法处于等待状态
        if(num == 0 ){
            try {
                wait();//等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //消费完面包了，所以面包数量降为0了
        num  =  num -1;//数量减1
        String name1 = Thread.currentThread().getName();
        System.out.println(name1+"买了一个面包编号为"+bid);
        notify();//当执行完后，去唤醒其他处于等待的线程
    }

    
    //setters and getters
   
    //有参构造
    public Breads(int bid, int num) {
        super();
        this.bid = bid;
        this.num = num;
    }

    //无参构造
    public Breads() {
    }
}

注意：

如果不是使用同步方法，而是使用同步代码块时，加的锁一定要满足以下两点要求：

1）不同种类的线程都要加锁

2）不同种类的线程加的锁必须是同一把

加锁的目的是锁住共享资源，而不是锁住操作共享数据的代码块。
因为，锁住资源之后，只要有一个线程（不管是否为同一个类型）在操作数据，其他的线程就不能操作，从而实现线程安全。

生产者类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class producer extends Thread{
    //获得面包的类
    private Breads bre ;

    //无参构造
    public producer() {
        super();
    }

    //有参构造
    public producer(Breads bre) {
        super();
        this.bre = bre;
    }


    //set和get方法
    public Breads getBre() {
        return bre;
    }

    public void setBre(Breads bre) {
        this.bre = bre;
    }

    //继承重写run方法
    @Override
    public void run() {
        pro();
    }
    
    //生产面包
    private void pro() {
        // 本系统默认循环生产20个面包
        for (int i = 0; i <20; i++) {
            try {
                Thread.currentThread().sleep(300);
            } catch (InterruptedException e) {         
                e.printStackTrace();
            }
            //调用面包类里的生产面包的方法
            bre.produc();
        }
    }
}
消费者类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class consume extends Thread{

    //获得面包的类
    private Breads bre ;
    
    //set和get方法
    public Breads getBre() {
        return bre;
    }
    public void setBre(Breads bre) {
        this.bre = bre;
    }
    
    //继承重写run方法
    @Override
    public void run() {
        con();
    }
    
    //消费面包
    private void con() {
        // 与生产者保持一致，本系统默认循环生产20个面包（生产几个，消费几个）
        for(int i = 0;i<20;i++){
            try {
                Thread.currentThread().sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //调用面包类里的消费面包的方法
            bre.consume();
        }
    }

    //有参构造
    public consume(Breads bre) {
        super();
        this.bre = bre;
    }

    //无参构造
    public consume() {
        super();
    }
}
测试类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestBreads {
    
    public static void main(String[] args) {
        
        //new一个面包类
        Breads bre = new Breads();
        
        //new一个生产者
        producer proth = new producer(bre);
        //new一个消费者
        consume conth = new consume(bre);
        
        //new一个包含消费者类的线程
        Thread t1 = new Thread(proth,"生产者");
        
        //new一个包含生产者类的线程
        Thread t2 = new Thread(conth,"消费者");
        
        //启动线程
        t1.start();
        t2.start();
        
    }
}
测试结果
1
2
3
4
5
6
7
生产者生产了一个编号为1的面包！
消费者买了一个面包编号为1
生产者生产了一个编号为2的面包！
消费者买了一个面包编号为2
生产者生产了一个编号为3的面包！
消费者买了一个面包编号为3
......
结果分析

如上所示，案例表明生产者消费者之间就是运用了wait()和notify()这两个方法，通过线程的等待与唤醒机制来完成两个不同线程操作统一数据之间的通信。

当生产者生产出一个面包时，立即去唤醒消费者，就像是对他说，你去买吧，我生产好了，然后消费者就会屁颠屁颠的去买了那个面包，当他吃完那个面包后，立即唤醒生产者，就像是对他说，你再生产一个吧，我吃完了，然后生产者就… … 如此循环，周而复始，直到for循环结束为止。

当然，也有可能生产者生产一个之后，它通知了消费者，但是生产者再次抢到执行权，想要继续生产。于是它查看面包的数量，却发现还是1，也就是面包还没有被消费，此时生产者就只能等待消费者消费完之后再生产。

同理，当消费者消费完一个面包之后，它通知了生产者，但是消费者再次抢到执行权，想要继续消费。于是它查看面包的数量，却发现还是0，也就是面包还没有被生产，此时消费者就只能等待生产者生产完之后在消费。

（二）生产与消费面包（多生产、多消费）

当我们创建多个生产者和消费者时，上述的代码就会出现一个问题，就是他们无法直到到底要唤醒哪一个，所以这时候我们就用到了notifAll()方法。
篇幅原因，代码就不在重复放出。其实与上面的差不多，唯一不一样的就是在面包类里的notify()换成notifAll()。
以下是多个生产者和消费者的测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class TestBreads {
    public static void main(String[] args) {
        
        //new一个面包类
        Breads bre = new Breads();
        
        //new一个生产者类
        producer proth = new producer(bre);
        //new一个消费者类
        consume conth = new consume(bre);
        
        //new三个包含消费者类的线程
        Thread t1 = new Thread(proth,"生产者1");
        Thread t3 = new Thread(proth,"生产者2");
        Thread t5 = new Thread(proth,"生产者3");
        
        //new三个包含生产者类的线程
        Thread t2 = new Thread(conth,"消费者1");
        Thread t4 = new Thread(conth,"消费者2");
        Thread t6 = new Thread(conth,"消费者3");
        
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
    }
}

测试结果如下:

1
2
3
4
5
6
7
8
9
生产者1生产了一个编号为1的面包！
消费者3买了一个面包编号为1
生产者2生产了一个编号为2的面包！
消费者2买了一个面包编号为2
生产者3生产了一个编号为3的面包！
消费者1买了一个面包编号为3
生产者1生产了一个编号为4的面包！
消费者3买了一个面包编号为4
......

如上所示，我们创建了三个生产者和三个消费者；

当进程开始后，会随机开启一个生产者线程，并在生产一个面包后，通知消费者，随后会唤醒所有消费者线程，但是只有一个消费者线程能抢到执行权，接着该消费掉刚刚生产的那个面包，然后通知生产者，随后会唤醒所有生产者线程，但是只有一个生产者线程能抢到执行权… 周而复始，直到结束。

五、状态转换图

可能有小伙伴会像我一样比较好奇，调用了wait()和notify()/notifyAll()方法后，线程的状态都会产生这样的变化。
因此，贴出一张线程的状态转换图：
线程状态转换图

六、总结

其实通过消费者-生产者模式来理解线程间的通信还是很简单的。
所以，好好弄懂这个案例吧！

本文大部分内容参考自线程之间的通信，并对部分内容进行了修改。

Java新手，若有错误，欢迎指正！

赏

都是码农，别客气了
| 阅读量59次

扫一扫，分享到微信

微信分享二维码
本站总访问量: 8001 本站总访客: 6254