Java并发学习 7: 线程之间的通信

灰太狼 2022-02-21 00:23 309阅读 0赞

### 文章目录 ###

*  7. 线程之间的通信
 *   *  7.1 synchronized和volatile关键字
     *  7.2 wait()和notify()方法进行线程通信
     *  7.3 用wait()和notify()实现生产者消费者模型
     *   *  7.4 Thread.join()的使用

# 7. 线程之间的通信 #

如果线程给仅仅是孤立的运行，那么价值不大，如果多个线程能够相互陪护完成工作，这将会带来巨大的价值。

## 7.1 synchronized和volatile关键字 ##

volatile关键字可以用来修饰字段(成员变量)，就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。

其底层实现是Lock指令，不仅能改变值后立刻刷新cache，还能防止JVM对代码重排序。

synchronized关键字可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一时刻，只能由一个线程处于方法或者同步块中，它保证了线程对变量访问的可能性和排他性。

同步代码块底层是monitorenter和monitorexit指令，同步方法底层是

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>底层实现</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>volatile</td> 
   <td>Lock指令</td> 
   <td>改变值后立刻刷新cache，还能防止代码重排造成的安全问题</td> 
  </tr> 
  <tr> 
   <td>synchronized同步方法</td> 
   <td>ACC_SYNCHRONIZED方法修饰符</td> 
   <td>本质上就是对monitor的获取，只允许一个线程对其获取，从而保证线程安全性。</td> 
  </tr> 
  <tr> 
   <td>synchronized同步代码块</td> 
   <td>monitorenter 和monitorexit</td> 
   <td>本质上就是对monitor的获取，只允许一个线程对其获取，从而保证线程安全性。</td> 
  </tr> 
 </tbody> 
</table>

![监视器，对象，同步队列和执行线程的关系][aHR0cHM6Ly9zMi5heDF4LmNvbS8yMDE5LzA4LzAyL2V3YXRUZi5wbmc]

1.  线程像访问一个受到synchronized保护的Object，首先要去尝试获得Object的监视器。
2.  如果获取失败，线程进入同步队列，线程状态变成 “BLOCKED”。
3.  当访问Object的前驱(获得了锁的线程)释放了锁，则该操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

## 7.2 wait()和notify()方法进行线程通信 ##

调用sleep方法可以让线程陷入休眠状态(状态图中的其他阻塞)，而wait()方法则会让线程陷入阻塞状态(等待阻塞)，sleep方法将在时间到达后醒来，而wait()方法则需要其他线程通过掀被子(notify())去叫醒。

给一个简单的双线程

public class Demo2 { 
        private volatile int signal;
    
        public void set(int value) { 
            this.signal = value;
        }
    
        public int get() { 
            return signal;
        }
    
        public static void main(String[] args) { 
            Demo2 d = new Demo2();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("开始get");
                    // wait和notify 都需要在同步代码块中
                    synchronized (d) { 
                        // 等待signal为1，开始执行，否则不能执行
                        // 让其自旋
                        while (d.get() != 1) { 
                            try { 
                                // 此时线程1在休眠，等待。
                                System.out.println("开始wait()");
                                d.wait();
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                        // 当信号为1时，执行代码
                        System.out.println("模拟代码运行");
                    }
                }
            }).start();
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("开始修改");
                    try { 
                        // 休眠以确保轮到get()线程执行.
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    // wait和notify 都需要在同步代码块中,因为线程需要拿到这把锁
                    synchronized (d) { 
                        d.set(1);
                        System.out.println("修改完成");
                        //set结束了，唤醒休眠状态的get()线程
                        d.notify();
                    }
                }
            }).start();
    
    
        }
    }
    // 运行结果.
    //开始get
    //开始wait()
    //开始修改 
    //修改完成
    //模拟代码运行

> 经典面试题：sleep()和wait()的区别是什么？
> 
> 1.  来自不同类：sleep()来自Object，wait()来自Thread。
> 2.  释放锁与否： sleep()不会释放锁，wait()会释放锁
> 3.  使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
>     
>     1.  synchronized(x)\{  
>         x.notify()  
>         //或者wait()  
>         \}
> 4.  捕捉异常：wait，notify和notifyAll无需捕捉异常，sleep()需要捕捉异常。

![wait()][wait]

## 7.3 用wait()和notify()实现生产者消费者模型 ##

简单介绍 :

> 在日常生活中，生产者生产食物，将其放入仓库，然后消费者消耗食物。
> 
> 如果生产者在生产前发现柜台满了，那么将开始看手机。
> 
> 消费者如果发现柜台为空，那么进入睡觉状态(睡着才能不饿).
> 
> 当消费者消耗食物后，柜台将变成不满，所以老板需要打断生产者的划水，让其干活。
> 
> 与之对应，当生产者生产东西后，应该叫醒快睡死的消费者，让他们起床吃饭。

接下来，我们将每一个生产者当作一个生产线程，将每一个消费者当作一个消费线程，而划水和睡觉是阻塞状态（wait() 操作），叫醒操作使用notifyAll操作。

import java.util.concurrent.TimeUnit;
    /** * 生产者--消费者模型 */
    public class Life { 
        public static void main(String[] args) { 
            Table t = new Table();
            int producersNum = 6;
            Thread[] producers = new Thread[producersNum];
            for (int i = 0; i < producersNum; i++) { 
                String name = i + "号生产者";
                producers[i] = new Thread(new Producer1(t), name);
                producers[i].start();
            }
            int consumerNum = 3;
            Thread[] consumers = new Thread[consumerNum];
            for (int i = 0; i < consumerNum; i++) { 
                String name = i + "号消费者";
                consumers[i] = new Thread(new Consumer1(t), name);
                consumers[i].start();
            }
        }
    }
    
    class Table { 
        private volatile int foodNum = 0;
        private final int maxTableSize = 10;
    
        public static void sleep() { 
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        public synchronized void addFood() { 
            if (this.foodNum < this.maxTableSize) { 
                this.foodNum++;
                System.out.println(Thread.currentThread().getName() + "在addFood()，还有" + this.foodNum + "份");
                notifyAll();
            } else { 
                // 食物已经堆满了桌子，厨师们开始划水
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    
        public synchronized void eatFood() { 
            // 消费
            if (this.foodNum > 0) { 
                this.foodNum--;
                System.out.println(Thread.currentThread().getName() + "吃了一份，还有" + this.foodNum + "份");
                // 柜台不是满的了，随机找一个人叫醒
                notifyAll();
            } else { 
                // 没啥可以吃了,客人们只能睡觉
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
    
    // 消费者
    class Consumer1 implements Runnable { 
        Table table;
    
        public Consumer1(Table table) { 
            this.table = table;
        }
    
        @Override
        public void run() { 
            for (; ; ) { 
                // 为了能看清楚
                Table.sleep();
                table.eatFood();
            }
        }
    }
    
    // 生产者
    class Producer1 implements Runnable { 
        Table table;
    
        public Producer1(Table table) { 
            this.table = table;
        }
    
        @Override
        public synchronized void run() { 
            for (; ; ) { 
                // 为了能看清楚
                Table.sleep();
                table.addFood();
            }
        }
    }

### 7.4 Thread.join()的使用 ###

**join()是干什么的？**

join()是插队的意思，也就是如果调用join的线程应该立刻得到CPU运行时间。

**为什么需要join()方法**

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

import java.util.concurrent.TimeUnit;
    
    /** * join() 方法练习 */
    public class Join { 
        public static void main(String[] args) throws InterruptedException { 
            Thread previous = Thread.currentThread();
            for (int i = 0; i < 10; i++) { 
                // 将前一个线程传给写一个线程
                Thread thread = new Thread(new Domino(previous), i + "");
                thread.start();
                previous = thread;
            }
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    
        static class Domino implements Runnable { 
            private Thread thread;
    
            public Domino(Thread thread) { 
                this.thread = thread;
            }
    
            @Override
            public void run() { 
                try { 
                    // 确保前一个线程先运行
                    thread.join();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " terminate");
            }
        }
    }
    /** main terminate. 0 terminate 1 terminate 2 terminate 3 terminate 4 terminate 5 terminate 6 terminate 7 terminate 8 terminate 9 terminate */

[aHR0cHM6Ly9zMi5heDF4LmNvbS8yMDE5LzA4LzAyL2V3YXRUZi5wbmc]: /images/20220221/ee5b3bed1ffb442f9314c3b8975ddf2e.png
[wait]: /images/20220221/777bb63326124fe88c6b3c1c70b103e7.png