多线程中的同步和通信

一、同步
方式一：同步代码块
*

• synchronized(同步监视器){

•  //需要被同步的代码
  

• }
• 说明：1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。

•   2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  

•   3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
  

•      要求：多个线程必须要共用同一把锁。
  

•   补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
  

• 方式二：同步方法。

• 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
  

• 5.同步的方式，解决了线程的安全问题。—好处
• 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —局限性
  使用同步方法解决实现Runnable接口的线程安全问题
• 关于同步方法的总结：
• 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
• 2. 非静态的同步方法，同步监视器是：this

• 静态的同步方法，同步监视器是：当前类本身*
  

• 解决线程安全问题的方式三：Lock锁 — JDK5.0新增

synchronized 与 Lock的异同？

• 相同：二者都可以解决线程安全问题

• 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

•    Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
  

• 2.优先使用顺序：

• Lock  同步代码块（已经进入了方法体，分配了相应资源）  同步方法（在方法体之外）

• class Window implements Runnable{

  private int ticket = 100;
  //1.实例化ReentrantLock
  private ReentrantLock lock = new ReentrantLock();

  @Override
  public void run() {
  while(true){
  try{

           //2.调用锁定方法lock()
           lock.lock();
  
           if(ticket > 0){
  
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
  
               System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
               ticket--;
           }else{
               break;
           }
       }finally {
           //3.调用解锁方法：unlock()
           lock.unlock();
       }
  
   }
  

  }
  }
  二、通信
  通信指的是线程和线程之间需要交替执行
  涉及到的三个方法：

• wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

• notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

• notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

• 说明：

• 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。

• 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。

• 否则，会出现IllegalMonitorStateException异常

• 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

• 面试题：sleep() 和 wait()的异同？

• 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

• 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()

•      2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
  

•      3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
  

• class Number implements Runnable{
  private int number = 1;
  private Object obj = new Object();
  @Override
  public void run() {

   while(true){
  
       synchronized (obj) {
  
           obj.notify();
  
           if(number <= 100){
  
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
  
               System.out.println(Thread.currentThread().getName() + ":" + number);
               number++;
  
               try {
                   //使得调用如下wait()方法的线程进入阻塞状态
                   obj.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
  
           }else{
               break;
           }
       }
  
   }
  

  }
  }

public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);

    t1.setName("线程1");
    t2.setName("线程2");

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

}

• 方式一和方式二的代码在day02的java1中，本文章主要参考了尚硅谷的课程