基于JUC的多线程与高并发

一、线程概述

1.1、线程的概念

1.1.1、进程

• 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是操作系统进行资源分配与调度的基本单位。
• 可以把进程简单的理解为正在操作系统中运行的一个程序。

1.1.2、线程

• 线程(thread)是进程的一个执行单元。
• 一个线程就是进程中一个单一顺序的控制流, 进程的一个执行分支 。
• 进程是线程的容器,一个进程至少有一个线程，一个进程中也可以有多个线程。
• 在操作系统中是以进程为单位分配资源,如虚拟存储空间,文件描 述符等。
• 每个线程都有各自的线程栈,自己的寄存器环境,自己的线程本地存储。

1.1.3、主线程与子线程

• JVM 启动时会创建一个主线程,该主线程负责执行 main 方法。
• 主线程就是运行 main 方法的线程。
• Java 中的线程不孤立的，线程之间存在一些联系
  • 如果在 A 线程中 创建了 B 线程, 称 B 线程为 A 线程的子线程, 相应的 A 线程就是 B 线 程的父线程

1.1.4、串行、并发与并行

• 串行
  
• 并发可以提高事务的处理效率，即一段时间内可以处理或者完成更多的事情。
• 并行是一种更为严格,理想的并发，从硬件角度来说,，如果单核 CPU，一个处理器一次只能执行一个线程的情况下，处理器可以使用时间片轮转技术 ,可以让 CPU 快速的在各个线程之间进行切换,，对于用户来说，感觉是三个线程在同时执行，如果是多核心 CPU,可以为不同的线程分配不同的 CPU 内核。

1.2、线程的创建与启动

• 在 Java 中,创建一个线程就是创建一个 Thread 类(子类)的对象(实 例)。
• Thread 类有两个常用 的构造方法:Thread()与 Thread(Runnable)
• 对应的创建线程的两种方式:
  • 定义 Thread 类的子类
  • 定义一个 Runnable 接口的实现类
  • 这两种创建线程的方式没有本质的区别
  • start()方法是同时执行，run()方法执行先进入run()方法体
• 线程创建流程
  • 定义类继承 Thread
  • 重写 Thread 父类中的 run
  • 创建子线程对象
  • 启动线程
• 注意事项
  • 调用线程的 start()方法来启动线程, 启动线程的实质就是请求 JVM运行相应的线程,这个线程具体在什么时候运行由线程调度器(Scheduler)决定
  • start()方法调用结束并不意味着子线程开始运行
  • 新开启的线程会执行 run()方法
  • 如果开启了多个线程,start()调用的顺序并不一定就是线程启动的顺序
  • 多线程运行结果与代码执行顺序或调用顺序无关
  • 运行无顺序，执行有顺序，静态方法>无参方法>普通方法>run()方法

1.2.1、创建线程

/**
 * @author hguo
 * @date2021/5/12 22:10
 * @title 创建线程执行类
 */
//1、继承Thread父类，重写run()方法
public class Createthread extends Thread {
    //run()就是子线程执行的任务
    @Override
    public void run() {
        System.out.println("子线程打印内容");
    }
    @Test
    public void createThread(){
        System.out.println("JVMQ启动main线程,main线程启动main方法!");
        //2、创建子线程对象
        Createthread createthread = new Createthread();
        //3、启动线程
        createthread.start();
        //4、打印线程启动结果
        System.out.println("main线程已启动");
    }
}

1.2.2、线程运行的随机性

/**
 * @author hguo
 * @date2021/5/12 22:44
 * @title 多线程随机运行
 */
public class CreateThreadRandom extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 1; i < 10; i++) {
                System.out.println("thread：" + i);
                int time = (int) (Math.random() * 1000);
                //线程随眠随机
                Thread.sleep(time);
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
    @Test
    public void CreateThreadRandom(){
        //2、创建子线程对象
        CreateThreadRandom createThreadRandom = new CreateThreadRandom();
        //3、启动线程
        createThreadRandom.start();
        try {
            for (int i = 1; i < 10; i++) {
                System.out.println("--main：" + i);
                int time = (int) (Math.random() * 1000);
                //线程随眠随机
                Thread.sleep(time);
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1.2.3、以Runnable接口创建线程

• 线程的执行具有随机性

• 实现流程

  • 定义实现类实现Runnable接口
  • 重写Runnable接口的抽象方法run()
  • 创建Runnable接口实现类对象
  • 创建线程对象
  • 启动线程 ```java /**
  • @author hguo
  • @date2021/5/12 23:14

  • @title Runnable接口创建线程 */ //1、定义实现类实现Runnable接口 public class RunnableCreateThread implements Runnable { //2、重写Runnable接口的抽象方法run() public void run() { //run()方法就是子线程执行的代码 for (int i = 1; i <10 ; i++) {

       System.out.println("thread: "+i);

    } }

    @Test public void RunnableCreateThread(){ //3、创建Runnable接口实现类对象 RunnableCreateThread runnableCreateThread = new RunnableCreateThread(); //4.创建线程对象 Thread thread = new Thread(runnableCreateThread); //5、启动线程 thread.start(); //run()方法就是子线程执行的代码 for (int i = 1; i <10 ; i++) {

       System.out.println("main: "+i);

    } } } ```

1.2.4、以Callable接口创建线程

• Callable接口有返回值，重写的是call()方法，需要抛出异常
• 创建步骤：
  • 创建目标对象
  • 执行服务

    ExecutorService threadPool = Executors.newSingleThreadExecutor();

• 提交执行

  Future<String> future = threadPool.submit(new CreateCallable());

• 获取结果

  future.get()

• 关闭服务

  threadPool.shutdown();

/**
 * @author hguo
 * @date2021/5/18 22:35
 * @title Callable接口实现
 */
public class CreateCallable implements Callable {
    @Override
    public Object call() throws Exception {
        // 模拟耗时任务
        Thread.sleep(1000);
        System.out.println("CreateCallable 线程：" + Thread.currentThread().getName());
        return "CreateCallable" ;
    }
    public static void main(String[] args) {
        System.out.println("main start");
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<String> future = threadPool.submit(new CreateCallable());
        try {
            // 这里会发生阻塞
            System.out.println(future.get());
        } catch (Exception e) {
        } finally {
            threadPool.shutdown();
        }
        System.out.println("main end");
    }
}

1.2.5、龟兔赛跑解析线程竞争

• 模拟龟兔赛跑的游戏，定义两个线程竞争一个资源，在此期间，设定兔子有休息时间

  /**
  * @author hguo
  * @date2021/5/18 21:59
  * @title 模拟龟兔赛跑解析线程竞争问题
  */
  public class TortoiseRabbitrRace extends Thread {
   //定义胜利者
   private static String winner;
   @Override
   public void run() {
       //设置长度
       for (int i = 0; i <=1000; i++) {
           //让兔子线程休眠,每10ms休眠一次
           if(Thread.currentThread().getName().equals("") && i%10==0){
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           //判断比赛是否结束
           boolean game = gameOver(i);
           //如果比赛结束就停止程序
           if(game){
               break;
           }
           System.out.println(Thread.currentThread().getName() + "-->跑了 " + i + "米");
       }
   }
   //判断比赛进度
   public boolean gameOver(int steps){
       //如何比赛结束，胜利者诞生
       if(winner!=null){
           return true;
       }
       //如果跑完长度等于100米，获取最先跑完的线程
       if(steps==1000){
           winner=Thread.currentThread().getName();
           System.out.println("winner is:" + winner);
           return true;
       }
       //没有跑完100米
       return false;
   }
   public static void main(String[] args) {
       //定义子线程
       TortoiseRabbitrRace race = new TortoiseRabbitrRace();
       new Thread(race,"乌龟").start();
       new Thread(race,"兔子").start();
   }
  }

1.3、线程的常用方法

• Java 中的任何一段代码都是执行在某个线程当中的
• 执行当前代码的线程就是当前线程.
• 同一段代码可能被不同的线程执行, 因此当前线程是相对的
• Thread.currentThread()方法的返回值是在代码实际运行时候的线程对象

1、常用方法

/**
 * @author hguo
 * @date2021/5/13 18:54
 * @title 线程常用方法
 */
//定义线程类
public class CurrentThreadMethod extends Thread{
    @Override
    public void run() {
        System.out.println("run方法打印线程："+Thread.currentThread().getName());
    }
    //无参构造
    public CurrentThreadMethod(){
        System.out.println("构造方法打印线程："+Thread.currentThread().getName());
    }
    @Test
    public void CurrentThreadMethod(){
        System.out.println("main方法打印线程：" +Thread.currentThread().getName());
        //创建子线程对象
        CurrentThreadMethod currentThreadMethod = new CurrentThreadMethod();
        //启动子线程
        currentThreadMethod.start();
        //run()方法不开启新的线程
        //currentThreadMethod.run();
    }
}

2、常用复杂方法

• setName()/getName()
• thread.serName(线程名称)，设置线程名称
• thread.getName() 返回线程名称
• 通过设置线程名称,有助于程序调试,提高程序的可读性, 建议为每个线程都设置一个能够体现线程功能的名

/**
 * @author hguo
 * @date2021/5/13 20:21
 * @title 复杂的线程方法
 */
public class CurrentThreadMethod2 extends Thread {
    //重写run方法
    @Override
    public void run() {
        System.out.println("run方法，Thread.currentThread().getName():"+Thread.currentThread().getName());
        System.out.println("run方法，this.getName():"+this.getName());
    }
    //定义无参构造
    public CurrentThreadMethod2() {
        System.out.println("构造方法,Thread.currentThread().getName():"+Thread.currentThread().getName());
        System.out.println("构造方法，this.getName():"+this.getName());
    }
    //执行测试
    @Test
    public void CurrentThreadMethod2() throws Exception {
        //创建子线程
        CurrentThreadMethod2 currentThreadMethod2 = new CurrentThreadMethod2();
        //设置线程名称
        currentThreadMethod2.setName("thread_2");
        //启动线程2
        currentThreadMethod2.start();
        //线程休眠
        Thread.sleep(500);
        //调用Thread(Runnable)构造方法，传入实参currentThreadMethod2
        Thread thread = new Thread(currentThreadMethod2);
        //启动线程3
        thread.start();
    }
}

3、isAlive()活动状态

• thread.isAlive()判断当前线程是否处于活动状态
• 活动状态就是线程已启动并且尚未终止

/**
 * @author hguo
 * @date2021/5/13 20:52
 * @title isAlive()活动状态的的使用
 */
//创建线程类
public class CurrentThreadMethod3 extends Thread {
    @Override
    public void run() {
        //查看run()的活动状态
        System.out.println("run方法,isAlive="+this.isAlive());
    }
    @Test
    public void CurrentThreadMethod3(){
        //创建子线程对象
        CurrentThreadMethod3 currentThreadMethod3 = new CurrentThreadMethod3();
        //查看子线程启动前活动状态
        System.out.println("start="+currentThreadMethod3.isAlive());
        //启动线程
        currentThreadMethod3.start();
        //查看子线程启动后活动状态
        System.out.println("end="+currentThreadMethod3.isAlive());
    }
}

4、sleep()线程睡眠

• Thread.sleep(millis); 让当前线程休眠指定的毫秒数
• 当前线程是指 Thread.currentThread()返回的线程
• 主线程启动，main方法就启动，main方法启动，子线程或run()方法才能启动（start只能启动线程，没有其他作用）
• 子线程或run()方法结束，main()方法才能结束，主线程才能结束

/**
 * @author hguo
 * @date2021/5/13 21:03
 * @title sleep()线程睡眠方法
 */
public class CurrentThreadMethod4 extends Thread{
    @Override
    public void run() {
        try {
            System.out.println("run,threadname="+Thread.currentThread().getName()+"，start-="+System.currentTimeMillis());
            //当前线程睡眠2秒
            Thread.sleep(2000);
            System.out.println("run,threadname="+Thread.currentThread().getName()+"，end-="+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void CurrentThreadMethod4(){
        //创建子线程
        CurrentThreadMethod4 currentThreadMethod4 = new CurrentThreadMethod4();
        //打印main方法启动
        System.out.println("main_start="+System.currentTimeMillis());
        //启动线程
        //currentThreadMethod4.start();
        //执行run()方法
        currentThreadMethod4.run();
        System.out.println("main_end="+System.currentTimeMillis());
    }
}

5、简单的sleep计数器

• 使用Thread.sleep()方法控制线程睡眠时间，从而达到计时的效果

/**
 * @author hguo
 * @date2021/5/13 21:19
 * @title sleep()实现计时器
 */
class SiomlpeTimer {
    public static void main(String[] args){
        //定义计时
        int times = 60;
        //读取main方法参数
        if(args.length ==1){
            times = Integer.parseInt(args[0]);
        }
        while (true){
            System.out.println("Times:"+times);
            times--;
            if (times<0){
                break;
            }
            try {
                //执行线程睡眠
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("时间到!");
    }
}

6、getId()线程唯一标识

• thread.getId()可以获得线程的唯一标识
• 注意的是
  • 某个编号的线程运行结束后,该编号可能被后续创建的线程使
  • 用重启JVM后同一个线程的编号可能不一样 ```java /**
  • @author hguo
  • @date2021/5/13 21:40
  • @title 获取线程唯一表示 */ public class GetIdThread extends Thread { @Override public void run() { System.out.println(“thread_name=”+Thread.currentThread().getName()+”,id=”+this.getId()); } @Test public void GetIdThread() throws Exception { System.out.println(“main_name=”+Thread.currentThread().getName()+”,id=”+Thread.currentThread().getId()); //获取子线程id for (int i = 1; i <100 ; i++) {

       new GetIdThread().start();
       Thread.sleep(100);

    } } } ```

7、yied()放弃CPU资源

• Thread.yield()方法的作用是放弃当前的 CPU 资源,也称线程让步

/**
 * @author hguo
 * @date2021/5/13 21:49
 * @title yield()线程让步，放弃CPU分配资源
 */
public class YieldThread extends Thread {
    @Override
    public void run() {
        long begin = System.currentTimeMillis();
        long sum =0;
        for (int i = 1; i <1000000 ; i++) {
            sum+=i;
            //线程让步，放弃CPU执行权
            Thread.yield();
        }
        long end = System.currentTimeMillis();
        System.out.println("run方法，用时:"+(end-begin)+"毫秒");
    }
    public static void main(String[] arg){
        //开启子线程，计算sum
        YieldThread yieldThread = new YieldThread();
        yieldThread.start();
        //在main线程中计算sum
        long begin = System.currentTimeMillis();
        long sum = 0;
        for (int i = 0; i <1000000 ; i++) {
            sum+=1;
        }
        long end =System.currentTimeMillis();
        System.out.println("main方法，用时："+(end-begin)+"毫秒");
    }
}

• 线程未让步时
  
• 线程让步后
  

8、setPriority()设置线程优先级

• Thread.setPriority( num )设置线程的优先级
• Java线程的优先级取值范围是 1 ~ 10 , 如果超出这个范围会抛出异常 IllegalArgumentException
• 在操作系统中,优先级较高的线程获得 CPU 的资源越多
• 线程优先级本质上是只是给线程调度器一个提示信息,以便于调度器决定先调度哪些线程， 注意不能保证优先级高的线程先运行
• Java 优先级设置不当或者滥用可能会导致某些线程永远无法得到运行,即产生了线程饥饿.
• 线程的优先级并不是设置的越高越好,一般情况下使用普通的优先级即可,即在开发时不必设置线程的优先级
• 程的优先级具有继承性, 在 A 线程中创建了 B 线程,则 B 线程的 优先级与 A 线程是一样的.

/**
 * @author hguo
 * @date2021/5/13 22:03
 * @title 设置线程优先级
 */
public class ThreadsetPriority  {
    static class ThreadsetPriorityA extends Thread{
        @Override
        public void run() {
            long begin = System.currentTimeMillis();
            long sum = 0 ;
            for(long i = 0 ; i<= 10000000; i++){
                sum += i;
            }
            long end = System.currentTimeMillis();
            System.out.println("thread A : " + (end - begin));
        }
    }
    static class ThreadsetPriorityB extends Thread{
        @Override
        public void run() {
            long begin = System.currentTimeMillis();
            long sum = 0 ;
            for(long i = 0 ; i<= 10000000; i++){
                sum += i;
            }
            long end = System.currentTimeMillis();
            System.out.println("thread B : " + (end - begin));
        }
    }
    public static void main(String[] args){
        //创建线程A对象
        ThreadsetPriorityA threadsetPriorityA = new ThreadsetPriorityA();
        //设置优先级
        threadsetPriorityA.setPriority(1);
        //启动线程A
        threadsetPriorityA.start();
        //创建线程B对象
        ThreadsetPriorityB threadsetPriorityB = new ThreadsetPriorityB();
        //设置优先级
        threadsetPriorityB.setPriority(9);
        //启动线程B
        threadsetPriorityB.start();
    }
}

• 不设置时
  
• 设置后
  

9、interrupt()线程中断

• 中断线程只是一个停止标志，真正的线程不会停止
• 注意调用interrupt()方法仅仅是在当前线程打一个停止标志,并不是真正的停止线程

/**
 * @author hguo
 * @date2021/5/13 22:22
 * @title 控制线程中断,只是做一个停止标志而非真正停止线程
 */
public class InterruptThread extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i = 1; i <= 10000; i++) {
            //判断线程的中断标志,线程有 isInterrupted()方法,该方法返回线程的中断标志
            if (this.isInterrupted()) {
                System.out.println("当前线程的中断标志为 true, 中断线程");
                //break; // 中断循环
                //run()方法体执行完毕, 子线程运行完毕
                //直接结束当前 run()方法的执行
                return;
            }
            System.out.println(" run --> " + i);
        }
    }
    public static void main(String[] args) {
        InterruptThread interruptThread = new InterruptThread();
        interruptThread.start(); ///开启子线程
        //当前线程是 main 线程
        for(int i = 1; i<=100; i++){
            System.out.println("main --> " + i);
        }
        //中断子线程
        interruptThread.interrupt(); ////仅仅是给子线程标记中断, }
    }
}

10、setDaemon()线程守护

• Java 中的线程分为用户线程与守护线程
• 守护线程是为其他线程提供服务的线程,如垃圾回收器(GC)就是一 个典型的守护线程
• 守护线程不能单独运行, 当 JVM中没有其他用户线程,只有守护线程时,守护线程会自动销毁, JVM 会退出

/**
 * @author hguo
 * @date2021/5/13 22:31
 * @title 守护线程
 */
public class ThreadsetDeamon extends Thread {
    @Override
    public void run() {
        super.run();
        while(true){
            System.out.println(" thread.....");
        }
    }
    public static void main(String[] args) {
        ThreadsetDeamon thread = new ThreadsetDeamon();
        //设置线程为守护线程且在线程启动前
        thread.setDaemon(true);
        thread.start();
        //当前线程为 main 线程
        for(int i = 1; i <= 10 ; i++){
            System.out.println("main== " + i);
        }
        //当 main 线程结束, 守护线程 thread 也销毁了
    }
}

1.4、线程的生命周期

1.4.1、线程周期介绍

• 线程的生命周期是线程对象的生老病死,即线程的状态
• 线程生命周期可以通过 getState()方法获得, 线程的状态是Thread.State实现的线程生命周期，分为5个部分：分别是新建状态、就绪状态、运行状态，阻塞状态、死亡状态。
  • new：新建状态。
    • 创建了线程对象,在调用start()启动之前的状态；
  • Runnable：就绪状态。
    • 当线程对象创建后，该线程对象自身或者其他对象调用了该对象的start()方法。该线程就位于了可运行池中，变的可运行，等待获取cpu的使用权。因为在同一时间里cpu只能执行某一个线程。
  • Running：运行状态。
    • 当就绪状态的线程获取了cpu的时间片或者说获取了cpu的执行时间，这时就会调用该线程对象的run()方法，然后就从就绪状态就入了运行状态。
  • Blocked：阻塞状态。
    • 阻塞状态就是线程因为某种原因暂时放弃了对cpu的使用权，暂时停止运行。直到线程再次进入就绪状态，才有机会转到运行状态。阻塞状态分为三种情况：
      • 等待状态：运行状态的线程调用了wait()方法后，该线程会释放它所持有的锁，然后被jvm放入到等待池中，只有等其他线程调用Object类的notify()方法或者norifyAll()方法时，才能进入重新进入到就绪状态。
      • 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，JVM就会把该线程设置为阻塞状态，一直到线程获取到同步锁，才能转入就绪状态。
      • 其它阻塞：运行的线程在执行sleep()或者join()方法时，或者发出了I/O请求，JVM就会把该线程设置为阻塞状态，当sleep()状态超时、join()等待等待线程终止或者超时、或者I/O处理完毕时，线程重进转入到就绪状态。在这需要注意的是sleep()方法和wait()不同，sleep不会释放自身所持有的锁。
  • Dead：死亡状态。
    • 当线程执行完了或者因异常退出了run()的执行，该线程的生命周期就结束了，死亡的线程不可再次复生。
• 自我理解（这个例子味道极重，得先酝酿）
  • 你去商城时突然想上厕所
    • 准备去上厕所这个过程，就是新建状态（new）
    • 人很多就要排队，排队的过程就是就绪状态（Runnable）
    • 终于有位置了，放飞自我的过程就是运行状态（Running）
    • 拉完后发现没有手纸，等待别人给送纸过来，这个状态就是阻塞（Blocked）
    • 上完厕所出来，上厕所这件事情结束了，就是死亡状态，也就是线程销毁（Dead）
  • 注意：便秘也是阻塞状态
    • 第一种情况，便秘太久了，别人等不及了，把你赶走，就是挂起
    • 另一种情况，便秘了，别人等不及了，跟你说你先出去酝酿一下，我先上，5分钟后再过来继续放飞自我，就是睡眠

1.4.2、多线程的适用分析

• 优势
  • 提高系统的吞吐率(Throughout)。多线程编程可以使一个进程有多个并发，同时进行的操作
  • 提高响应性(Responsiveness)。Web服务器会加快了程序的响应速度，缩短了用户的等待时间
  • 充分利用多核(Multicore)处理器资源。 通过多线程可以充分的 利用 CPU 资源
  • 可以分别设置优先级以优化性能
• 缺点
  • 线程安全(Thread safe)问题。多线程共享数据时,如果没有采取正确的并发访问控制措施，就可能会产生数据一致性问题。如数据脏读，丢失数据更新
  • 线程活性(thread liveness)问题。由于程序自身的缺陷或者由资源稀缺性导致线程一直处于非 Runnable状态，这就是线程活性问题, 常见的活性故障有以下几种：
    • 死锁(Deadlock)。
      • 多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。类似于有结果的死循环原理
      • 造成原因
        • 恶性竞争资源
        • 进程间推进顺序非法（插队）
      • 死锁的必要条件
        • 互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
        • 请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
        • 不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
        • 环路等待条件：在发生死锁时，必然存在一个进程—资源的环形链。
      • 预防死锁
        • 资源一次分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）
        • 剥夺资源：当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）
        • 资源有序分配：按照序号分配资源，每一个进程按编号递增的顺序请求资源。
    • 活锁(Livelock)。
      • 线程1可以使用资源，但它很礼貌，让其他线程先使用资源，线程2也可以使用资源，但它很绅士，也让其他线程先使用资源。这样你让我，我让你，最后两个线程都无法使用资源。类似无结果的死循环原理
    • 饥饿(Starvation)。
      • 是指如果线程T1占用了资源R，线程T2又请求封锁R，于是T2等待。T3也请求资源R，当T1释放了R上的封锁后，系统首先批准了T3的请求，T2仍然等待。然后T4又请求封锁R，当T3释放了R上的封锁之后，系统又批准了T4的请求……，T2可能永远等待。类似于请求无响应原理
  • 上下文切换(Context Switch)。
    • 处理器从执行一个线程切换到执，行另外一个线程
  • 可靠性。
    • 可能会由一个线程导致 JVM 意外终止，其他的线程也无法执行

1.5、线程安全问题

1.5.1、线程的原子性

• 原子(Atomic)就是不可分割的意思。原子操作的不可分割有两层含义:
  • 访问(读,写)某个共享变量的操作从其他线程来看，该操作要么已经执行完毕要么尚未发生，即其他线程看不到当前操作的中间结果
  • 访问同一组共享变量的原子操作是不能够交叉的，如现实生活中从 ATM 机取款, 对于用户来说,要么操作成功,用户拿到钱, 余额减少了,增加了一条交易记录; 要么没拿到钱,相当于取款操作没有发生
  • Java 有两种方式实现原子性：
    • 一种是使用锁;
    • 另一种利用处理器 的 CAS(Compare and Swap)指令。锁具有排它性，保证共享变量在某一时刻只能被一个线程访问，CAS 指令直接在硬件(处理器和内存)层次上实现，看作是硬件锁

1.5.2、线程的可见性

• 在多线程环境中, 一个线程对某个共享变量进行更新之后 , 后续其他的线程可能无法立即读到这个更新的结果, 这就是线程安全问 题的另外一种形式: 可见性(visibility)
• 如果一个线程对共享变量更新后, 后续访问该变量的其他线程可 以读到更新的结果, 称这个线程对共享变量的更新对其他线程可见, 否则称这个线程对共享变量的更新对其他线程不可见
• 多线程程序因为可见性问题可能会导致其他线程读取到了旧数据 (脏数据)

1.5.3、线程的有序性

• 有序性(Ordering)是指在什么情况下一个处理器上运行的一个线程所执行的内存访问操作在另外一个处理器运行的其他线程看来是乱序的(Out of Order）
• 乱序是指内存访问操作的顺序看起来发生了变化

1、重排序

• 在多核处理器的环境下,编写的顺序结构,这种操作执行的顺序可能是没有保障的:
  • 编译器可能会改变两个操作的先后顺序;
  • 处理器也可能不会按照目标代码的顺序执行;
  • 这种一个处理器上执行的多个操作,在其他处理器来看它的顺序与目标代码指定的顺序可能不一样,这种现象称为重排序
  • 重排序是对内存访问有序操作的一种优化,可以在不影响单线程程序正确的情况下提升程序的性能.但是,可能对多线程程序的正确性产生影响,即可能导致线程安全问题
  • 重排序与可见性问题类似,不是必然出现的
• 与内存操作顺序有关的几个概念:
  • 源代码顺序, 就是源码中指定的内存访问顺序.
  • 程序顺序, 处理器上运行的目标代码所指定的内存访问顺序
  • 执行顺序,内存访问操作在处理器上的实际执行顺序
  • 感知顺序,给定处理器所感知到的该处理器及其他处理器的内存访问操作的顺序
• 可以把重排序分为指令重排序与存储子系统重排序两种
  • 指令重排序主要是由 JIT 编译器,处理器引起的, 指程序顺序与执
  • 行顺序不一样存储子系统重排序是由高速缓存,写缓冲器引起的, 感知顺序与执行顺序不一致

2、指令重排序

• 在源码顺序与程序顺序不一致,或者程序顺序与执行顺序不一致的情况下,我们就说发生了指令重排序(Instruction Reorder).
• 指令重排是一种动作,确实对指令的顺序做了调整, 重排序的对象指令
• javac 编译器一般不会执行指令重排序, 而 JIT 编译器可能执行指令重排序.
• 处理器也可能执行指令重排序, 使得执行顺序与程序顺序不一致
• 指令重排不会对单线程程序的结果正确性产生影响,可能导致多 线程程序出现非预期的结果.

3、存储子系统重排序

• 存储子系统是指写缓冲器与高速缓存.
• 高速缓存(Cache)是 CPU 中为了匹配与主内存处理速度不匹配而设计的一个高速缓存
• 写缓冲器(Store buffer, Write buffer)用来提高写高速缓存操作的效率

二、多线程底层机制

2.1、Java内存模式

• 每个线程都又独立的栈空间
• 每个线程都可以访问堆内存
• CPU不会直接从内存上读取数据，而是通过高速缓存来实现数据读取
• 计算机读取数据时并不是直接从CPU中读取，而是从内存中的缓存区读取，将数据读取到寄存器中
• 每个线程都能从寄存器中读取数据，但是在不同的CPU上不能相互读取，因为寄存器是独立的
• CPU、缓存区、寄存器都是相互独立的，不能跨域读取。但是达成缓存一致性协议时，可以读取别的缓存区的数据，这种情况称为缓存同步
  
• 线程共享
  • 每个线程之间的共享数据都存储在主内存中
  • 每个线程都有一个私有的本地内存
  • 每个线程从主内存中把数据读取到本地内存中，保存副本线程并处理，该线程数据情况只对当前线程可见

• Java运行时存储
  • Java运行时(Java runtime)空间可以分为栈区,堆区与方法区(非堆空 间)
  • 栈空间(Stack Space)为线程的执行准备一段固定大小的存储空间, 每个线程都有独立的线程栈空间,创建线程时就为线程分配栈空间.
  • 在线程栈中每调用一个方法就给方法分配一个栈帧，栈帧用于存储方法的局部变量，返回值等私有数据， 即局部变量存储在栈空间中, 基本类型变量也是存储在栈空间中, 引用类型变量值也是存储在栈空间中，引用的对象存储在堆中.
  • 由于线程栈是相互独立的,一个线程不能访问另外一个线程的栈空间，因此线程对局部变量以及只能通过当前线程的局部变量才能访问的对象进行的操作具有固定的线程安全性

2.2、线程安全机制

2.2.1、线程安全的两种常见方法

• 线程加锁 ```java //获取锁对象 对象名.lock(); threadValue value =new threadValue(); value.lock();

//释放锁对象 value.unlock();

-  添加同步代码块或者同步方法 
```java
//执行同步方法，在线程定义的方法中添加synchronized关键字
public synchronized void doLongTimeTest() {
......
}
//添加同步代码块
public  void doLongTimeTest() {
 synchronized (this){
   ......      
      }
}

2.2.2、线程同步

• 线程同步机制是一套用于协调线程之间的数据访问的机制.该机 制可以保障线程安全
• Java 平台提供的线程同步机制包括:
  • 锁, volatile 关键字, final 关键 字,static 关键字
  • 相关的 API,如 Object.wait()/Object.notify()等

2.2.3、锁机制

• 锁(Lock)可以理解为对共享数据进行保护的一个许可证，对于同 一个许可证保护的共享数据来说，任何线程想要访问这些共享数据必须先持有该许可证
• 一个锁只能被一个线程持有，但是一个线程可以持有多个锁
• 线程安全问题的产生前提是多个线程并发访问共享数据
• 将多个线程对共享数据的并发访问转换为串行访问，即一个共享数据一次只能被一个线程访问。锁就是复用这种思路来保障线程安全的
• 锁的持有线程在获得 锁之后和释放锁之前这段时间所执行的代码称为临界区
• 当线程出现异常时，会自动释放锁，届时线程安全无法保障
• 锁具有排他性(Exclusive), 即一个锁一次只能被一个线程持有。这种锁称为排它锁或互斥锁(Mutex)
  
• JVM中的锁
  • 内部锁通过 synchronized 关键字实现
  • 显示锁通过 java.concurrent.locks.Lock 接口的实现类实现的

2.2.4、锁的作用

• 锁可以实现对共享数据的安全访问
• 保障线程的原子性,可见性与有序性
• 锁是通过互斥保障原子性
• 可见性的保障是通过写线程冲刷处理器的缓存和读线程刷新处理器缓存这两个动作实现的
• 锁能够保障有序性.写线程在临界区所执行的在读线程所执行的 临界区看来像是完全按照源码顺序执行的
• 使用锁保障线程的安全性,必须满足以下条件：
  • 这些线程在访问共享数据时必须使用同一个锁
  • 即使是读取共享数据的线程也需要使用同步锁

2.2.5、锁的其他概念

• 可重入性
  • 一个线程在持有一个锁的同时再次申请该锁或其他锁的行为
• 锁的争用与调度
  • Java 平台中内部锁属于非公平锁,，显示 Lock 锁既支持公平锁又支 持非公平锁
• 锁的粒度
  • 一个锁可以保护的共享数据的数量大小称为锁的粒度
  • 锁保护共享数据量大,称该锁的粒度粗
  • 锁的粒度过粗会导致线程在申请锁时会进行不必要的等待
  • 锁的粒度过细会增加锁调度的开销
• 排他锁
  • Java 中的每个对象都有一个与之关联的内部锁(Intrinsic lock).
  • 这种锁也称为监视器(Monitor), 可以保障原子性,可见性与有序性

2.2.6、synchronized 同步代码块

• 同步可以理解未串行
• 创建两个线程对象，执行start()方法，线程是同时运行的，两个执行的线程子对象都能获取CPU的执行权
• synchronized 排他锁开启后，就只有一个线程能够获取CPU执行权，第二个线程只能进入等待区等待现场一执行完，才启动线程
• JVM执行的过程是自上到下，所以默认了最前面一个线程对象首先获取CPU执行权
• 实现线程同步，必须保证两个或多个线程子对象一致，确保锁对象的一致性，不然无法实现线程同步的效果

• 锁的同步

  /**
  * @author hguo
  * @date2021/5/19 22:21
  * @title synchronized同步代码块
  */
  public class synchronized_01 {
   //定义方法打印字符串
   public void print(){
       //经常使用this当前对象最为锁对象
       synchronized (this){
           for (int i = 0; i <= 100; i++) {
               System.out.println(Thread.currentThread().getName() + "-->" + i);
           }
       }
   }
   public static void main(String[] args) {
       final synchronized_01 synchronized_01 = new synchronized_01();
       //thread-0
       new Thread(new Runnable() {
           @Override
           public void run() {
               //使用锁的对象this就是synchronized_01对象
               synchronized_01.print();
           }
       }).start();
       //thread-1
       new Thread(new Runnable() {
           @Override
           public void run() {
               synchronized_01.print();
           }
       }).start();
   }
  }

• 同步代码块与同步方法的对比

  /**
  * @author hguo
  * @date2021/5/19 22:21
  * @title synchronized同步代码块与同步方法的效率对比
  */
  public class Synchronized_02 {
   public void doLongTimeTest1() throws InterruptedException {
       System.out.println("Test start");
       //模拟线程准备3秒时间
       Thread.sleep(3000);
       //执行同步代码块
       synchronized (this){
           System.out.println("开始同步");
           for (int i = 0; i < 101; i++) {
               System.out.println(Thread.currentThread().getName() + "-->" + i);
           }
       }
       System.out.println("Test end");
   }
   public synchronized void doLongTimeTest() throws InterruptedException {
       System.out.println("Test start");
       //模拟线程准备3秒时间
       Thread.sleep(3000);
       //执行同步代码块
       synchronized (this){
           System.out.println("开始同步");
           for (int i = 0; i < 101; i++) {
               System.out.println(Thread.currentThread().getName() + "-->" + i);
           }
       }
       System.out.println("Test end");
   }
   public static void main(String[] args) {
       //创建线程子对象
       final Synchronized_02 synchronized_02 = new Synchronized_02();
       //创建线程一
       new Thread(new Runnable() {
           @Override
           public void run() {
               try {
                   synchronized_02.doLongTimeTest();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }).start();
       //创建线程二
       new Thread(new Runnable() {
           @Override
           public void run() {
               try {
                   synchronized_02.doLongTimeTest();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }).start();
   }
  }

• 同步代码块，锁的粒度细，执行效率相对来说，较高
• 同步方法，需要进入方法体再运行，效率较低

2.2.7、脏读

• 出现读取属性值出现了一些意外, 读取的是中间值,而不是修改之后的值
• 出现脏读的原因
  • 对共享数据的修改或读取不同步

• 解决方法

  • 不仅对修改数据的代码块进行同步,还要对读取数据的代码块同步 ```java /**
  • @author hguo
  • @date2021/5/19 22:21

  • @title 脏读 */ public class Synchronized_03 { static class publicValue{ private String name = “hello”; private String pwd = “123456”;

    public void getValue(){

       System.out.println(Thread.currentThread().getName() + ",getter -- name :" + name + ", -- pwd:" + pwd);

    } public void setValue(String name,String pwd){

       this.name=name;
       try {
           //模拟线程准备1秒
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       this.pwd=pwd;
       System.out.println(Thread.currentThread().getName() + ",setter -- name:" + name + ", --pwd:" + pwd);

    } }

//定义线程，设置用户名和密码 static class SubThread extends Thread{ private publicValue publicValue; public SubThread(publicValue publicValue){ this.publicValue=publicValue; } @Override public void run() { publicValue.setValue(“hello11”,”111”); } }

public static void main(String[] args) throws InterruptedException { //开启子线程 publicValue publicValue = new publicValue(); SubThread subThread = new SubThread(publicValue); subThread.start(); //等待线程开启 Thread.sleep(1000); //读取信息 publicValue.getValue(); }

}

2.2.8、死锁

• 造成死锁的原因：

• 在多线程程序中，同步时可能需要使用多个锁，如果获得锁的顺序不一致，就可能造成死锁

• 如何避免：

• 当需要获得多个锁时,所有线程获得锁的顺序保持一致即可

2.3、轻量级同步机制(volatile)

2.3.1、volatile关键字的作用

• 使变量在多个线程之间可见，解决了线程之间的可见性和有序性
• 内存可见性（Memory Visibility）：所有线程都能看到共享内存的最新状态。
• 防止指令重排序

2.3.2、volatile于Synchronized的区别

• volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比 synchronized要好;

• volatile只能修饰变量，而synchronized可以修饰方法以及代码块；

• 多线程访问volatile变量不会发生阻塞，而synchronized可能会阻塞；

• volatile 能保证数据的可见性，但是不能保证原子性; 而 synchronized 可以保证原子性，也可以保证可见性；

• 关键字volatile解决的是变量在多个线程之间的可见性，synchronized 关键字解决多个线程之间访问公共资源的同步性

2.3.3、volatile的非原子性

• volatile 关键字增加了实例变量在多个 线程之间的可见性,但是不具备原子性

2.4、JUC线程安全(重点)

2.4.1、理解JUC

• JUC实质是一个包类名，是==Java.util.concurrent==的首字母简写
• 在JUC中包含了线程安全的实现方法及各类锁机制
• 在Java应用中，几乎涵盖了所有底层安全的内容

2.4.2、 线程安全的两种实现方法

1、Synchronized线程同步

• synchronized是悲观锁，这种线程一旦得到锁，其他需要锁的线程就挂起的情况就是悲观锁。
• 线程是一个单独的资源类，没有任何附属的操作，在发开中，尽量保障线程干净
• 一个好的线程中只能有属性和方法两样东西
• 线程同步就是线程有序执行，保证锁的正常获取和释放

/**
 * @author hguo
 * @date2021/5/23 14:30
 * @title 定义售票线程
 */
public class SaleThread {
 static class Sale{
     //定义属性，总票数
     private int num = 13;
     //定义买票方法,设置同步方法
     public synchronized void sales(){
         if(num>0){
             System.out.println(Thread.currentThread().getName() + "卖出了" + (num--) + "票,还剩" + num + "票");
         }
     }
 }
  public static void main(String[] args) {
      //多线程操作同一个资源
      //定义线程对象
      final Sale sale = new Sale();
      new Thread(() -> {
          for (int i = 0; i < 4; i++) {
              sale.sales();
          }
      }, "A").start();
      new Thread(() -> {
          for (int i = 0; i < 5; i++) {
              sale.sales();
          }
      }, "B").start();
      new Thread(() -> {
          for (int i = 0; i < 6; i++) {
              sale.sales();
          }
      }, "C").start();
  }
}

2、Lock机制实现线程同步

• lock锁包括了读锁、写锁、读写锁、可重入锁等
• 相较于Synchronized同步，lock更加轻便灵活
• 在lock锁中还有公平锁和非公平锁
  • 公平锁：必须保证线程和锁的同步
  • 非公平锁：可以插队，可按照执行实现分配线程和锁的顺序，默认是非公平锁
• 锁的使用
  • 加锁、lock.lock();
  • 业务代码
  • 解锁、lock.unlock();

    //加锁操作
         lock.lock();
         try {
             if(num>0){
                 System.out.println(Thread.currentThread().getName() + "卖出了" + (num--) + "票,还剩" + num + "票");
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             //解锁
             lock.unlock();
         }

• 实例说明

  /**
  * @author hguo
  * @date2021/5/23 14:30
  * @title 定义售票线程
  */
  public class SaleThreadLock {
  static class Sale{
      //定义属性，总票数
      private int num = 13;
      //定义锁
      Lock lock=new ReentrantLock();

  
  }
  }

##### 3、Synchronized与Llock的区别
* 所在包结构不同
* Synchronized是**java内置的关键字**，Lock是一个Java类
* Synchronized**无法判断获取锁状态**，Lock可以判断是否获取到锁的状态
* Synchronized**会自动释放锁**，Lock要手动释放，如果不及时释放，将会造成死锁
* Synchronized在多线程运行时，可**能会造成多线程等待或阻塞**的情况，Lock不会
* Synchronized是**可重入的，不能中断，默认非公平锁**，Lock可重入，可中断，可选择是否公平锁或非公平锁
#### 2.4.3、生产者和消费者模式
##### 1、JVM级别的生产者与消费者
* 成对出现，一个生产对应一个消费，要让线程同步才能做到一一对应
* 开发使用
* 等待
* 业务
* 通知
```java
/**
 * @author hguo
 * @date2021/5/23 15:37
 * @title 线程生产者与消费者
 */
public class ProducerConsumer {
    static class Data{
        private int num = 0;
        //+1,生产者
        public synchronized void increment() throws InterruptedException {
            if(num!=0){
                //等待操作
                this.wait();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "--->" + num);
            //通知线程，+1完毕
            this.notifyAll();
        }
        //-1，消费者
        public synchronized void decrement() throws InterruptedException {
            if(num==0){
                //等待操作
                this.wait();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "--->" + num);
            //通知线程，-1完毕
            this.notifyAll();
        }
    }
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

• 虚假唤醒，多线程中常见的问题之一（在现有A、B两个线程的基础上，再加线程就可能导致这个问题）

  • if判断容易造成虚假唤醒
  • 当线程中满足条件时，需求变更加线程时，if判断改成while判断即可
  • 原因时if只能单次判断，while可以多次判断 ```java /**
  • @author hguo
  • @date2021/5/23 15:37

  • @title 线程生产者与消费者 */ public class ProducerConsumer {

    static class Data{ private int num = 0; //+1,生产者 public synchronized void increment() throws InterruptedException {

       while(num!=0){
           //等待操作
           this.wait();
       }
       num++;
       System.out.println(Thread.currentThread().getName() + "--->" + num);
       //通知线程，+1完毕
       this.notifyAll();

    }

    //-1，消费者 public synchronized void decrement() throws InterruptedException {

       while (num==0){
           //等待操作
           this.wait();
       }
       num--;
       System.out.println(Thread.currentThread().getName() + "--->" + num);
       //通知线程，-1完毕
       this.notifyAll();

    } }

    public static void main(String[] args) { Data data = new Data(); new Thread(()->{

       for (int i = 0; i < 10; i++) {
           try {
               data.increment();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

    },”A”).start(); new Thread(()->{

       for (int i = 0; i < 10; i++) {
           try {
               data.decrement();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

    },”B”).start(); new Thread(()->{

       for (int i = 0; i < 10; i++) {
           try {
               data.increment();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

    },”C”).start(); new Thread(()->{

       for (int i = 0; i < 10; i++) {
           try {
               data.decrement();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

    },”D”).start(); } } ```

2、JUC级别的生产者和消费者

• JUC中，lock锁的等待使用的是await()方法
• 传统方法中，synchronized等待使用的是wait()方法

• conditon的优势

  • JUC中lock锁的condition默认方法是随机执行的
    
  • 实现condition精准唤醒通知，多定义多执行，开发中不建议使用 ```java **
  • @author hguo
  • @date2021/5/23 15:37

  • @title 线程生产者与消费者 */ public class ProducerConsumerJUC2 {

    static class Data{ private int num = 1; //定义锁 Lock lock = new ReentrantLock(); Condition condition1 = lock.newCondition(); Condition condition2 = lock.newCondition(); Condition condition3 = lock.newCondition(); Condition condition4 = lock.newCondition(); ```
    }

2.4.4、八锁现象理解（重点）

1、多个线程使用同一把锁，顺序执行

• 多个线程持有一个对象，共用一把锁，执行顺序只与上下顺序有关，先调用先执行

• 示例：标志访问，先打电话还是先发短信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title 多个线程使用同一把锁，顺序执行
  */
  public class Lock_01 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized void sendinfo(){
           System.out.println("---->发短信");
       }
       public synchronized void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
  }

  
  

2、多个线程使用同一把锁，其中某线程里存在阻塞，顺序执行

• 多个线程持有一个对象，共用一把锁，执行顺序只与上下顺序有关，先调用的先执行，即使在某方法中设置了阻塞。

• 示例：邮件方法暂停4秒钟，先打电话还是短信？

   /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title 多个线程使用同一把锁，顺序执行
  */
  public class Lock_02 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
  }

  
  

3、多个线程有锁无锁共存，无锁先行

• 有的线程有锁，有的线程无锁，线程之间不存在竞争同一把锁的情况，在不干涉无锁线程的前提下先后执行顺序是无锁先执行，因为它不用去竞争对象锁

• 示例：新增一个普通方法接收微信()没有同步，请问先打印邮件还是接收微信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title 多个线程有锁无锁共存，无锁先行
  */
  public class Lock_03 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized void call(){
           System.out.println("---->打电话");
       }
       //接收微信，没有锁
       public void getWeChat() {
           System.out.println("---->打开微信");
       }
   }
   public static void main(String[] args) {
       Phone phone = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
       new Thread(()->{phone.getWeChat();},"C").start();
   }
  }

  
  

4、多个线程使用多把锁，随机执行

• 被 synchronized 修饰的方法，锁的对象是方法的调用者,调用者不同，它们之间用的不是同一个锁，相互之间没有竞争关系。
• 没有其他元素干扰的条件下，按照上下顺序执行，有干扰时，谁用时最短谁先执行

• 示例：两部手机、请问先打印邮件还是短信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title 多个线程使用多把锁，随机执行
  */
  public class Lock_04 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone_1 = new Phone();
       Phone phone_2 = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone_1.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone_2.call();},"B").start();
   }
  }

  
  

5、class锁：多个线程使用一个对象，顺序执行

• 被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁，线程之间是顺序执行。

• 锁Class和锁对象的区别：
  1、Class 锁 ，类模版，只有一个,加载既有；
  2、对象锁 ， 通过类模板可以new 多个对象。
  如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
  示例：两个静态同步方法，同一部手机，请问先打印邮件还是短信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title class锁：多个线程使用一个对象，顺序执行
  */
  public class Lock_05 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized static void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized static void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
  }

  
  

6、class锁：多个线程使用多个对象，顺序执行

• 被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。
• Class锁是唯一的，所以多个对象使用的也是同一个Class锁。

• 示例：两个静态同步方法，2部手机，请问先打印邮件还是短信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title class锁：多个线程使用多个对象，顺序执行
  */
  public class Lock_05 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized static void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized static void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone_1 = new Phone();
       Phone phone_2 = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone_1.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone_2.call();},"B").start();
   }
  }

  
  

7、class锁与对象锁：多个线程使用一个对象，顺序执行

• 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
• 只被synchronized修饰的方法，是普通锁，不是Class锁，线程之间不存在竞争同一把锁的情况，顺序执行。

• 实例：一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

  /**
  * @author hguo
  * @date2021/5/23 21:18
  * @title class锁：多个线程使用多个对象，顺序执行
  */
  public class Lock_06 {
   //定义一个功能类
   static class Phone{
       //功能类中实现功能的具体方法，synchronized修饰线程同步
       public synchronized static void sendinfo(){
           //干扰，使线程睡眠一秒
           try {
               TimeUnit.SECONDS.sleep(4);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("---->发短信");
       }
       public synchronized void call(){
           System.out.println("---->打电话");
       }
   }
   public static void main(String[] args) {
       Phone phone = new Phone();
       //两个线程公用一个phone对象，先调用先执行
       new Thread(()->{phone.sendinfo();},"A").start();
       //干扰，使线程睡眠一秒
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
  }