多线程

0.冯·诺伊曼体系

image-20210802015609167

大部分计算机，都是遵守冯诺依曼体系的，不光是台式机，笔记本，包括手机，路由器，交换机，嵌入式设备

除冯诺依曼体系之外，还有一种“哈佛结构”

CPU——>中央处理器，进行算术运算和逻辑判断(核心设备)

CPU这个东西，可以说就是目前人类科技的巅峰之作——>制造难度不下于氢弹

CPU工作流程

CPU的核心功能，就是执行一些“指令”

CPU在设计生产的时候，就会提供一组API东西，就可以称之为指令

指令就是一组二进制的数据，用来表示一些特定的含义

Java代码最终都会被编译器/JVM转换成一条一条的CPU指令。最终在CPU上执行

C++直接把源代码编译成二进制的机器指令了

1.多线程概述

进程

程序：未完成指定任务，用某语言编写的一组指令的集合，（静态代码、对象）

进程：程序的一次执行，或是正在运行的一个程序，是一个动态的过程，由产生，存在，消亡的过程–>生命周期

为啥要引入进程:

  1. 操作系统能够支持”多任务”(功能手机始时代，操作系统就可以视为是单任务的)

  2. 更充分地利用CPU资源

进程是如何管理的

  1. 描述：task struct

  2. 组织：双向链表

  3. 进程的调度——并行/并发

不过由于Java不太涉及到多进程编程，支持也比较有限，所以Java多进程基本不用

线程

进程是为了实现并发编程的效果，但是为了追求更高的效率就引入了线程 创建一个进程/销毁一个进程，开销比较大(进程管理着一些系统分配的资源,申请/释放这些资源不是一个简单的事情) 因此就希望能够更高效，更轻量的完成并发编程——>线程

线程也可以称为“轻量级进程”

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 每个线程就对应到一个”独立的执行流”在这个执行流里就能完成一系列的指令 多个线程，就有了多个执行流，就可以并发的完成多个系列的指令了

  1. 一个程序有多个线程，但只是一个进程

  2. 进程在干多件事，线程只是其中一件

  3. 笼统地说，一个线程就是一个java.lang.Thread类的实例

    1. Java虚拟机会为一个Thread实例分配两种调用栈（Call Stack）所需的内存空间（也可能是一个调用栈实现两者功能）

    2. 一种用于跟踪Java代码间的调用关系

    3. 一种用于跟踪Java代码与本地代码（Native代码）的调用关系

并行/并发

  • 并行：多个CPU同时执行多个任务

    • 微观角度讲，每个进程和进程之间是同时执行的

    • 比如：多个人同时做不同的事、8核CPU核心可以执行8个进程

  • 并发：一个CPU（采用时间片）同时执行多个任务

    • 宏观角度讲，进程是”同时”执行，一个CPU负责执行3个进程，进程1的逻辑···迅速切换到进程2执行···迅速切换到进程3执行···一次来回切

    • 由于CPU切换速度极快，宏观来看好像是几个进程同时执行

    • 比如秒杀平台，多个人做同件事

具体什么时候并发什么时候并行？

要明确目的是提高效率(更充分地利用CPU资源) 如果是并发的话，光是一个CPU执行，效率是有限的 如果是并行的话，就可以利用两个CPU效率就更快 但实际上，到底是并发还是并行，完全取决于调度器的工作

线程&进程

进程和线程的关系:

  1. 一个进程包含了多个线程

  2. 一个进程其实就是从系统这里申请了很多的系统资源——>进程统一对这些资源进行管理——>这个进程内的多个线程，就共享了这些资源

进程和线程的区别:(高频题目)

  • 进程具有”独立性”——>一个进程挂了，不会影响到其他进程

  • 而线程则是，如果一个生产线挂了，可能会影响到整个进程的工作

可以这么回答:

  1. 进程包含线程——>一个进程包含一个线程，也可以包含多个线程

  2. 进程是资源分配的基本单位，西安城市系统调度执行的基本单位

  3. 进程和进程之间，是相互独立的，进程A挂了，不会影响到进程B,同一个进程的若晗哥线程之间，共享着一些资源

  4. 如果某个线程出现异常，可能会导致整个进程终止，但进程自身是独立的(挂就挂了不会影响别的)

站在JVM的角度来看:

JVM内存区域划分，这也是一个进程，JVM在启动的时候，会申请一大片内存资源，并且把这个内存资源划分成若干个区域 方法区\堆:多个线程共享的区域 栈/程序计数器:每个线程有自己的区域

站在操作系统的角度来看:

其实并不是如此，整个进程的虚拟地址空间，都是由若干个线程共享的

String s = new String(“hello”);//s这个引用本身是在哪个内存区域上？ s这个东西在哪，和自身是不是引用类型，没关系，和它是局部变量，还是成员变量有关系 所以随意给这么一行出来答案就是不知道 放在方法内部,就是在栈上 放在类中,就是在堆上(要是加上static就是在方法区)

2.线程的相关API

  1. 获取当前线程的名字

Thread.currentThread().getName()

  1. 启动当前线程

start();

  1. 调用线程中的run方法，通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

run();

  1. 静态方法，返回执行当前代码的线程

currentThread();

  1. 获取当前线程的名字

getName();

  1. 设置当前线程的名字

setName();

  1. 主动释放当前线程的执行权

yield();

  1. 在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去

join();

  1. 过时方法，当执行此方法是，强制结束当前线程

stop();

  1. 判断当前线程是否存活

isAlive();

getId()

getName()//不手动指令则系统自动分配Thread-0,Thread-1…

getState()//状态,NEW/RUNNABLE/

isDaemon()//是否为后台线程

getPriority()//优先级

isAlive()

isInterrupted()

扩展：

  • 状态：是Java的线程状态，和操作系统中的进程/线程的状态类似，但并不相同

  • 优先级：和线程调度相关，但最终还是由操作系统来完成(给线程设置优先级，并不能起到决定性作用)

  • 后台线程&前台线程：

    • 后台：不会影响到整个进程的结束(主线程结束后还能执行)

      • 一个线程如果不是后台线程(Daemon守护线程)意味着当主线程(main结束时，该线程仍然会继续执行，进程仍然存在

      • 如果一个线程被设定成守护线程，当主线程(main)结束时，该线程就不会继续执行了，进程退出

      • JVM上的进程会在所有非后台线程结束后,才会结束运行

    • 前台：会影响到整个进程的结束

  • 存活：判定线程是否已经结束,(但有可能线程结束，但是还未销毁)

  • 线程中断问题，后续了解

判断多线程

根据原理，一条线程即为一条执行路径，即当能用一条路径画出来时即为一个线程

线程调度

调度策略

时间片：线程的调度采用时间片轮转的方式

抢占式：高优先级的线程抢占CPU Java的调度方式

  1. 对于同优先级的线程组成先进先出队列（先到先服务），使用时间片策略

  2. 对高优先级，使用优先调度的抢占式策略

3.创建多线程

start方法

是Thread类的一个关键方法

start的功能就是”让操作系统内核，真正创建一个线程来执行“

虽然Java中的Thread实例和系统中的线程是一一对应的关系，但是两者的生命周期不是完全一样的

start与run方法的区别

start方法的作用

  1. 启动当前线程

  2. 调用当前线程的重写的run方法（在主线程中生成子线程，有两条线程）

因而，start方法，默认启动的同时，自动调用重写了的run方法

子类的run方法是重写的方法，是如何被执行到的呢?

是因为Java的多态

start()方法里面就会尝试执行，先创建一个线程，在县城内部调用this.run此处的run到底执行父类的方法还是子类的方法，取决于this的指向

所以就是多态,多态就例如：Servlet的doPost方法之类

多态带来的一个很大的影响，就是允许程序员对现有的代码中的一部分进行"扩展"允许程序员把一段自己定制好的逻辑，插入到"现有的代码框架中"...

所以说区别：

  1. 调用start方法是创建了线程(才有执行流)

  2. 调用run方法是执行一个run普通方法(),就是借用原来的(线程)路径

    1. 则程序的执行会卡在run方法上，不会继续向下走

不应该出现手动调用run方法的情况，run就是在start内部自动执行的

3.1继承于Thread类

  1. 创建一个继承于Thread类的子类（通过ctrl+o(override)输入run查找run方法）

  2. 重写Thread类的run()方法

  3. 创建Thread子类的对象

  4. 通过此对象调用start()方法

通过Thread定义 new一个自定义对象，然后重写run方法

image.png点击并拖拽以移动原本的run源码

public class TestThread{
    public static void main(String[] args) {
        Thread thread = new CustomThread();
        thread.start();
    }
    static class CustomThread extends Thread{
        @Override
        public void run(){
            System.out.println("Running...");
        }
    }
}

点击并拖拽以移动

示例1：火车票

public class TestThread extends Thread{
    //火车票窗口
    public static void main(String[] args) {
        window t1 = new window();
        window t2 = new window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t1.start();
        t2.start();
    }

    static class window extends Thread{
        private int ticket = 10;//将其加载在类的静态区，所有线程共享该静态变量

        @Override
        public void run(){
            while(true){
                if(ticket>0){
/*                    try{
                        sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }*/
                    System.out.println(getName() + "当前售出第" + ticket + "张票");
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

点击并拖拽以移动

3.2通过Runnable

public class TestThread{
    public static void main(String[] args) {
        System.out.println("在main方法调用"+Thread.currentThread().getName());
        Helper helper = new Helper("whc\'s Thread");
        helper.run();
    }
    static class Helper implements Runnable{
        private final String message;
        public Helper(String message){
            this.message = message;
        }
        private void doSomething(String message){
            System.out.println("doSomething   "+Thread.currentThread().getName());
            System.out.println("do something   " + message);
        }
        public void run(){
            doSomething(message);
        }
    }

点击并拖拽以移动

运行结果：

image.png点击并拖拽以移动

Runable例子买票

public class ttThread implements Runnable{
    //通过实现runable接口的方式
    private  int ticket = 10;
    public void run(){
        while(true){
            if(ticket<=0)break;
            System.out.println(Thread.currentThread().getName()+" --卖出了第"+ticket--+"张票");
        }
    }
    public static void main(String[] args) {

        ttThread t3 = new ttThread();
        Thread tt1 = new Thread(t3,"window1");
        Thread tt2 = new Thread(t3,"window2");
        Thread tt3 = new Thread(t3,"window3");
        tt1.start();
        tt2.start();
        tt3.start();
    }
}

点击并拖拽以移动

Runnable例子龟兔赛跑

//龟兔赛跑
public class TestRunable implements Runnable{
    private static String winner;
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                try{
                    Thread.sleep(2);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flg = gameOver(i);
            if(flg)break;
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否存在胜利者
        if(winner != null){
            //存在成立者
            return true;
        }else{
            if(steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        TestRunable T1 = new TestRunable();
        Thread t1 = new Thread(T1,"兔子");
        Thread t2 = new Thread(T1,"乌龟");
        t1.start();
        t2.start();
    }
}

点击并拖拽以移动

3.3Callable接口实现多线程

image.png点击并拖拽以移动

4.静态代理模式

静态代理模式例子结婚

//静态代理模式
public class TestMarry {
    public static void main(String[] args) {
        WeddingCompany weddingC = new WeddingCompany(new Person());
        weddingC.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色
class Person implements Marry{
    public void HappyMarry(){
        System.out.println("结婚过程中");
    }
}

//代理角色
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target = target;
    }
    public void HappyMarry(){
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("婚后,收钱");
    }

    private void before() {
        System.out.println("婚前，布置现场");
    }
}

点击并拖拽以移动

静态代理模式总结

1.真实对象和代理对象都要实现同一个接口

2.代理对象要代理真实角色

好处：

1.代理对象可以做很多真实对象做不了的事情

2.真实对象专注于左自己的事情

5.Lamda表达式

为什么使用lambda表达式

  • 避免匿名内部类定义过多

  • 可以让代码看起来很简洁

  • 去掉了一堆没有意义的代码，只留下核心的逻辑

  • 多敲多练，才会适应习惯

函数式接口（Functional Interface）

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

对于函数式接口，可以通过lambda表达式来创建该接口的对象

  1. 定义一个函数式接口（只有一个抽象方法）

  2. 定义其实现类，来重写其方法

  3. main内，new对象，调用其重写的方法

  4. 局部内部类，在main方法内部定义一个类，实现接口，并重写其方法，然后new对象调用

  5. 匿名内部类，没有类的名称，直接new 接口，直接在语句上重写方法

  6. lambda表达式like = ()->{ 重写方法 };（jdk1.8以后出现的功能）

这就是jdk的对于代码简化化的过程

public class TestLambda {
    //3.静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        //3.new对象，调用实现类方法s
        Ilike like = new Like();//接口new一个实现类
        like.lambda();
        Ilike like2 = new Like2();
        like2.lambda();

        //4.局部内部类
        class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        like = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化   jdk1.8
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();


    }
}

//1.定义一个函数式接口
interface Ilike{
    void lambda();//抽象方法
}

//2.实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("i like lambda1");
    }

}

点击并拖拽以移动

针对lambda的简化

        //简化1.参数类型
        ILove love1 = (a) ->{
            System.out.println("i love youyouyou" + a);
        };
        //简化2.括号
        ILove love2 = a ->{
            System.out.println("i love youyouyou" + a);
        };
        //简化3.花括号
        ILove love3 = a -> System.out.println("i love youyou " + a);

点击并拖拽以移动

lambda表达式简化总结：

  1. 能去掉花括号因为代码只有一行（同if省略花括号的使用）,多行则要用代码块（花括号）包裹

  2. 前提是函数式接口

  3. 参数类型简化，多个参数也可以去掉其类型（但是要么都去掉，要么都不去掉）,且必须加上括号

Lambdas及函数式接口的例子

1.多线程的Runnable接口

image.png点击并拖拽以移动

其他的：

使用案例 Lambda 的例子 对应的函数式接口
布尔表达式 (List list) -> list.isEmpty() Predicate
创建对象 () -> new Apple(10) Supplier
消费一个对象 (Apple a) -> System.out.println(a.getWeight()) Consumer
从一个对象中 选择/提取 (String s) -> s.length() Function或 ToIntFunction
合并两个值 *(int a, int b) -> a * b* IntBinaryOperator
比较两个对象 (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()) Comparator或 BiFunction 或 ToIntBiFunction

6.线程操作

6.1停止线程

原则：

  1. 推荐让线程自己停下来——>利用次数，不建议死循环（伤害CPU）

  2. 建议使用标志位——>设置一个标志位

  3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法

public class Thread12 implements Runnable{
    //1.设置一个标识位
    private  boolean  flg = true;
    @Override
    public void run() {
        int i =0 ;
        while(flg){
            System.out.println("run--- Thread  " + i++);
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flg = false;
    }

    public static void main(String[] args) {
        Thread12 test = new Thread12();
        new Thread(test).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if(i == 900){
                //调用stop方法切换标志位，让县城停止
                test.stop();
                System.out.println("线程停止!");
            }
        }
    }
}

6.2中断线程

  1. 让线程的入口方法执行完毕(比如Thread.run)

  2. 使用Thread类提供的interrupt方法(thread.interrupt())——>线程中断

    1. 把while里面判定的标记为改成了基于Thread.currentThread().isInterrupted()——>内置的标记位，不用用户手动创建代码来判定

    2. 把catch里面的代码，加一个break，本质上还是期望让线程的任务方法能够执行结束

    3. 使用interrupt方法来中断的时候，可能涉及到两种情况

      1. 如果当前线程内部执行的逻辑不涉及到sleep这样的等待，此时就会通过这个标记位来进行推出

      2. 如果当前线程内部执行的逻辑已经进入sleep了，此时就会触发一个InterruptedException，通过catch捕获到异常，在继续决定如何处理

Thread中有两种方式判定interrupt方法的标记位

  • Thread的静态方法：Thread.interrupted();调用之后自动清除标记位

  • Thread的非静态方法：Thread.currentThread().isInterrupted();调用之后不会自动清除标记位——>主要用这个方法

点击并拖拽以移动

6.3线程休眠sleep

所谓进程的调度，操作系统实际调度的基本单位就是线程

操作系统内核里为了管理所有的进程/线程，使用链表进行管理

image-20210807172654884

CPU执行分为

  1. 就绪队列——>CPU执行队列，但是实际什么时候给你操作，还是看CPU心情的

  2. 等待队列——>sleep的线程，就在这里进行等待，时间到了就挪回就绪队列

等待队列中的县城可能有好多个，这些线程谁应该先出队列，先回到就绪队列中呢？

和设定的等待事件相关，。这个等待队列不是一个简单的先进先出队列，而是一个优先级队列

语法：sleep(时间);

实际上就是让线程休眠，作用在于模拟网络延迟.

每个对象都有一把锁，sleep不会释放锁——>这里用于与wait进行对比

例子：模拟倒计时

public class TestSleep implements Runnable{
    //通过实现runable接口的方式
    public void run() {
        for (int i = 10; i >= 1; i--) {
            try {
                Thread.sleep(1000);
                System.out.println(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        TestSleep t3 = new TestSleep();
        Thread tt1 = new Thread(t3, "window1");
        tt1.start();
    }
}

点击并拖拽以移动

例子：显示时间

这里要注意：

    1. 一个是new SimpleDateFormat("HH:MM:SS")

    2. format(startTime)注入时间

    3. 每次循环都要重新更新一下时间，这样才能让时间走动起来

Date startTime = new Date(System.currentTimeMillis());
        while(true){
            try{
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:MM:SS").format(startTime));
                startTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

点击并拖拽以移动

6.4线程礼让yield

礼让线程，让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让CPU重新调度，礼让不一定能成功，主要看CPU心情（估计我电脑CPU心情不大好）

public class TestYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"start");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"end");
    }
    public static void main(String[] args) {
        TestYield t1 = new TestYield();
        TestYield t2 = new TestYield();
        new Thread(t1,"线程1").start();
        new Thread(t2,"线程2").start();
    }
}

点击并拖拽以移动

6.5线程强制执行Join——>等待线程

创建了多个线程之后，每个线程都是一个独立的执行流 这些线程每个1线程执行的先后顺序都是不确定的，完全取决于操作系统的调度·

等待线程机制就是一种确定线程先后顺序的方式，确定线程的”结束顺序” 无法保证线程1和线程2谁先执行，但是能够保证线程1一定先于线程2执行完毕

Thread.join

join起到的效果就是等待某个线程结束。谁调用join就等待谁结束

Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞（这里区别于礼让）

join分为

  1. 无参数join()等待线程结束

  2. 有参数join(long millis)设定等待时间，等待并不是无限的等

    1. 比如说插队的线程好久都没完毕，等待有一个限度

  3. 更高精度的参数join(long millis,int nanus)同理，只是加了个纳秒，精度更高，不常用

    1. 毕竟计算机计时很难达到那么精确(线程调度本身也是消耗时间的)

  4. 可以想象成插队行为

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("线程VIP来了" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin t1 = new TestJoin();
        Thread tt = new Thread(t1);
        tt.start();
        //主线程
        for (int i = 0; i < 200; i++) {
            if(i == 50){
                tt.join();//直接插队
            }
            System.out.println("main" + i);
        }
    }
}

点击并拖拽以移动

  1. 在main方法中调用t.join()，相当于在主线程中，等待t线程结束

main方法执行到join就会阻塞等待，一直等到t线程执行完毕(t的run方法跑完了),这个时候join才会继续往下执行

public class Main{
	public static void main(String[] args) {
    	Thread t = new Thread(() -> System.out.println("起飞！"));
    	t.start();

    	try {
        	t.join();
    	} catch (InterruptedException e) {
        	e.printStackTrace();
    	}
	}
}

join的经典用法：

很多时候需要多线程来完成一个任务，例如：多线程下载数据

拿过来梳理我的线程逻辑

6.6获取对象引用

Thread.currentThread();返回当前线程对象的引用

在哪个线程中调用，就获取到哪个线程对象的引用

public class TestThread4 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                //
                System.out.println(Thread.currentThread().getId());
            }
        };
        t1.start();

        Thread t2 = new Thread(){
            @Override
            public void run() {
                //
                System.out.println(Thread.currentThread().getId());
            }
        };
        t2.start();
    }
}

  • 获取线程实例，如果线程是通过创建Thread子类，并重写run的方式来创建的话

    • 此时在run方法中，使用this，也就直接能找到该线程对象的引用——>同样可以使用currentThread()

  • 如果线程是通过Runnable或lambda的方式来创建的话，就不能用this，只能用currentThread()

7.线程常用操作

线程状态观测

Thread.State

image-20210808093149185

线程状态包括：

  1. NEW

    1. 尚未启动的线程处于此状态

  2. RUNNABLE

    1. 在Java虚拟机中执行的线程处于此状态

  3. BLOCKED

    1. 被阻塞等待监视器锁定的线程处于此状态

  4. WAITIN

    G

    1. 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

  5. TIMED WAITING

    1. 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

  6. TERMINATED

    1. 已退出的线程处于此状态

image-20210808093532368

由此可见，isAlive()所判断的状态，就是非TERMINATED和NEW状态的

一个线程可以在给定时间点处于一个状态，这些状态·是不反映任何操作系统线程状态的虚拟机状态

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("///");
        }) ;

        //观察状态
        Thread.State state = t1.getState();
        System.out.println(state);//NEW

        //观察启动后状态
        t1.start();
        state = t1.getState();
        System.out.println(state);//RUNNABLE

        while(state != Thread.State.TERMINATED){
            //只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = t1.getState();//更新线程状态
            System.out.println(state);//输出状态TIMED_WAITING
        }
    }
}

点击并拖拽以移动

死亡后的线程不能复活

image.png点击并拖拽以移动

image.png点击并拖拽以移动

线程优先级Priority

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

线程优先级用数字表示，范围1~10

  • Thread.MIN_PRIORITY = 1;

  • Thread.MAX_PRIORITY = 10;

  • Thread.NORM_PRIORIT = 5;

  • 使用以下方式改变或获取优先级

    • getPriority().setPriority(inr xxx)

注意：

  1. 优先级的设定要在Start前

  2. 优先级低只是调度的概率低，并时不时一定优先级就不会被调用了，这都是看CPU脸色的

  3. 性能倒置：优先级低的先调度了，反了！

8.线程安全

多线程虽然是更轻量的(相较于多进程来说)来完成了并发编程

多个线程是访问同一份内存资源的

由于县城是一个”抢占式”执行的过程(这些线程谁先执行，谁后执行，不确定，完全取决于系统的调度器)

  • 由于这里的不确定性太多，就可能会导致多个线程访问同一个资源的时候，出现BUG

    • 访问分为读和写

      • 如果只读的线程，没有线程安全问题

      • 多个线程涉及到写，才会有线程安全问题

线程不安全成因

针对内存中的数据进行修改操作都是CPU负责完成的，所以说CPU的操作流程:

  1. 先把内存的数据读取到CPU的寄存器中

  2. 针对寄存器的内容，通过类似于ADD这样的指令进行+1操作，操作结果仍然是放在寄存器中

  3. 把寄存器中的数据，写回到内存中

注意：所有的拿和放，都不是取走数据本身，而是复制的关系

所以真正导致不安全的成因：

  1. 线程的抢占式执行过程(根源)

    1. 随机性的来源，万恶之源(而且是由操作系统内核实现的，程序员控制不了)

  2. 修改同一个数据

  3. 修改操作非原子性的

    1. 进程相互穿插操作，以确保数据的正确

    2. 保证操作的原子性，是保证线程安全问题的主要手段

  4. 内存可见性(因编译器优化导致的)

    1. 两个线程同时操作一个内存，比如一个读一个写

      1. 写操作的线程进行了修改的时候 读操作读取道德可能是修改前的结果，也可能是修改后的结果

    2. 按照原本的逻辑进行操作：涉及到大量的读写内存操作，可能会导致

    3. 内存可见性本质就是，编译器优化导致了线程1修改的数据没有及时的写入到内存中，线程2就读取不到最新的数据(读到的是一个就的数据)

    4. 编译器会在整体逻辑不变的情况下堆生成指令进行调整，做出一些更优化的执行方案，提高程序的效率

    5. 但是对于单线程来说直接优化没问题，多线程直接优化的话就可能会导致数据存在问题

    6. 解决可见性问题：方案就是进制直接编译器优化，让程序跑的慢点没关系，关键是能算对

  5. 指令重排序(因编译器优化导致的)

    1. 针对编译器优化而对安全性进行干预

    2. 编译器会自动对顺序进行调整，且调整的前提一定是保证逻辑不变

      1. 单线程，自动调整会提速

      2. 但是针对多线程人性化程度并不可观

编译器优化搞出这么多问题，但是仍然能够利大于弊

在面试中提到不安全性问题，都是从实际例子的角度出发，不能直接按性质走

保证线程安全，主要从后三点开始入手

JMM—>Java内存模型

留坑！

插入一个测试的面经

设计测试用例，一定不能脱离需求，一定不能脱离功能点 当面试官给一个常见的时候，千万不要一上来就开始设计测试用例

先梳理出当前场景的需求和功能点，才是第一步要做的 然后再根据功能点来设计测试用例

测试用例设计应该是，用例设计的越多，越好，用例设计的越详细越好 一个场景的测试用例，能说多少说多少，多多益善

其实，安全性测试、兼容性测试，往往是不重要的 相对于功能来讲，并不重要，或是说说也说不明白，只是知道有这个东西存在，不懂装懂罢了

9.守护线程（daemon）

守护线程vs用户线程

Java中的线程分为守护线程（Daemon Thread）和用户线程（User Thread）

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

用户线程会阻止Java虚拟机的正常停止

即Java虚拟机正常停止前应用程序中的所有用户线程必须先停止；否则Java虚拟机无法停止

正常停止：

指虚拟机既不是通过System.exit调用来停止的，也不是通过强制停止进程的方式来停止的（如在Linux系统下使用kill命令停止Java进程）

守护线程则不会影响Java虚拟机的正常停止

即应用程序中由守护线程在运行也不影响Java虚拟机的正常停止

因此，守护线程通常用于一些不太重要的任务，例如，垃圾回收机制、监视其他线程的运行情况的任务

垃圾回收机制：

  1. 在main方法周围随时进行回收

  2. 当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾

  3. JVM的一个系统级线程会自动释放该内存块

垃圾回收意味着程序不再需要的对象是”无用信息”，这些信息将被丢弃

当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用

事实上，除了释放没用的对象，垃圾回收也可以清除内存记录碎片

由于创建对象和垃圾回收器释放丢弃对象所占的内存空间，内存会出现碎片

碎片是分配给对象的内存块之间的空闲内存洞

碎片整理将所占用的堆内存移到堆的一端，JVM将整理出的内存分配给新的对象

守护线程例子：上帝与你

public class TestDaemon {
 public static void main(String[] args) {
     God god = new God();
     You you = new You();
     Thread thread = new Thread(god);
     thread.setDaemon(true);//默认是false表示用户线程，整行来讲都是用户线程,这里设置成true就是守护线程
     thread.start();//上帝守护线程启动
     new Thread(you).start();//用户线程启动！
 }
}

//上帝
class God implements Runnable{
 @Override
 public void run() {
     while(true){
         System.out.println("上帝保佑你！");
     }

 }
}

//你
class You implements Runnable{
 @Override
 public void run() {
     for (int i = 0; i < 36500; i++) {
         System.out.println("你一生开心的活着");
     }
     System.out.println("-=====goodbye！world!======");
 }
}

点击并拖拽以移动

你结束了goodbye！上帝不会结束，虚拟机因为你死了，而即将关闭，虚拟机不管上帝，但是关闭需要点时间，所以你死了以后还得跑一会儿上帝

img点击并拖拽以移动

10.线程同步

在Java中，new出来的对象，存放在堆中，对象中，存在一个对象头，包含了对象的一些属性信息，其中有一个字段，就是该对象的监视器锁状态 使用synchronized进行加锁解锁的时候，就涉及到修改指定对象的对象头信息

在多个线程竞争同一个锁对象时(尝试对同一个对象加锁，此时就会出现一个竞争成功，其他等待的情况) 如果多个线程竞争不同的锁，则线程都能成功获取到锁

image-20210808151251777

多个资源操作一个资源——>并发（一个对象被多个线程同时操作）

并发：一个CPU（采用时间片）同时执行多个任务，比如秒杀平台，多个人做同件事

现实生活的例子：银行取钱、食堂排队打饭、买火车票

处理多线程问题：多个线程访问同一个对象，并且某些线程想要修改这个对象

这时候就需要线程同步，线程同步其实就是以中等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

队列与锁

为了安全从而存在 由于统一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据再方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起（降低性能）

  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题

  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

不安全案例

买票

//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"张辉").start();
        new Thread(station,"张帅").start();
        new Thread(station,"余天乐").start();

    }
}

class BuyTicket implements Runnable{
    private int ticketNums = 10;
    boolean flg = true;
    @Override
    public void run() {
        //买票
        while(flg){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flg =false;
            return ;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "拿到"+ticketNums--);
    }

}

点击并拖拽以移动

img点击并拖拽以移动

三个人同时看到剩一张了，同时去拿了（人会知道没票了，但程序不懂）

存在负数，不安全！

取钱

//不安全的取钱（也是同时取钱）
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing yourgirlFriend = new Drawing(account,100,"你媳妇");
        you.start();
        yourgirlFriend.start();
    }

}
//账户
class Account{
    int money;//余额
    String name;//卡名


    public Account(int money,String name){
        this.money = money;
        this.name  = name;
    }
}
//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;


    }

    //取钱

    @Override
    public void run() {
        //判断有没有钱
        if(account.money-drawingMoney < 0){
            System.out.println(Thread.currentThread().getName() +"钱不够了，取不了");
            return;
        }
        //sleep可以放大问题的发生性
        try{
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内余额 = 余额 - 你去的钱

        account.money = account.money - drawingMoney;
        //手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name+"余额为：" + account.money);
        System.out.println(this.getName() + "手里的钱" + account.money);
    }
}

点击并拖拽以移动

img点击并拖拽以移动

List就是不安全的

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()-> {
                list.add(Thread.currentThread().getName());
            }).start();

        }
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

点击并拖拽以移动

11.synchronized同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，包括两种用法：

  • synchronized方法——>同步方法：public synchronized void method(int args){}

  • synchronized块，直接synchronized(被加锁对象){ 内容 }

synchronized方法控制对于”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

缺陷：若将一个大的方法声明为synchronized将会影响效率

img点击并拖拽以移动

synchronized的优势：除了块或方法，自动解锁，不像是C语言之类需要手动解锁

同步方法

上述例子，买票，实现同步（逻辑上。排队买票）

//将购买，改成synchronized同步方法,锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flg =false;
            return ;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "拿到"+ticketNums--);
    }

点击并拖拽以移动

方法里面需要修改的内容才需要锁，锁太多浪费时间

同步块

synchronized(Obj){}

Obj称之为 同步监视器

  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[]

同步监视器执行过程：

  1. 第一个线程访问，锁定同步监视器，执行其中代码

  2. 第二个线程访问，1发现同步监视器被锁定，无法访问

  3. 第一个线程访问完毕，解锁同步监视器

  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

上述取钱例子，利用同步块

 //synchronized默认锁的是this
    @Override
    public void run() {
        synchronized (account){
            //判断有没有钱
            if(account.money-drawingMoney < 0){
                System.out.println(Thread.currentThread().getName() +"钱不够了，取不了");
                return;
            }

            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额 = 余额 - 你去的钱

            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name+"余额为：" + account.money);
            System.out.println(this.getName() + "手里的钱" + account.money);

        }
    }

点击并拖拽以移动

img点击并拖拽以移动

同理list不安全问题

new Thread(()-> {
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();

点击并拖拽以移动

同步总结

synchronized本质上就是锁，把并发线程变成了串行，解决了抢占式执行带来的随机信

方法只是锁类，同步块是可以锁任何东西

同步块锁的对象是变化的量——>就是需要增删改的对象

可重入锁

嵌套执行synchronized加锁操作会发生什么？

也就是说一下两个代码段同时出现——>

image-20210808153137959

image-20210808153149867

这会导致死锁！！

自己卡自己脚

以上关于死锁，确实如此，只不过synchronized技高一筹，这种情况称之为可重入锁

诸如此类代码，在实际开发中还是很常见的

synchronized内部记录了当前这把锁是哪个线程持有的 如果当前加锁线程和持有锁线程是同一个线程 此时并不是真的进行”加锁操作”，而是把一个计数器++

如果后续该线程继续尝试获取锁，继续判定加锁线程持有所线程是不是同一个线程 只要是同一个线程，就不真正加锁而是计数器++ 如果该线程调用解锁操作，也并不是真的解锁，而是计数器– 直到计数器减到0了，才释放锁

各种编程语言，大部分都高估了程序员的智商，唯独Java认为程序员都是rz

12.volatile

也是辅助保证线程安全

针对线程不安全因素:

volatile能够禁止指令重排序，保证内存可见性，但是不保证原子性

为什么不保证原子性?

如果两个线程都要写，此时volatile无能为力，还要靠synchronized

应用场景:

主要用于读写同一个变量的时候

这是一个针对内存可见性的线程安全问题代码：

线程1，循环执行，循环条件是判定flag为0 线程2，允许用户输入一个整数，修改flag 预期的效果是，用户输入非0值，线程1就结束了 但实际上并没有如此，就是由于内存可见性导致的

import java.util.Scanner;

public class TestThread6 {
    static class Counter{
        public int flag = 0;
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(()->
        {
            while(counter.flag == 0){
				//这个循环执行速度非常快，如果不优化，此时CPU频繁的读取内存数据(读内存比读寄存器慢很多)
            //编译器就会把这个读操作优化成只从内存(主内存)中读一次，后续都直接读寄存器/缓存(工作内存)
            }
            System.out.println("线程1循环结束");
        });
        t1.start();

        Thread t2 = new Thread(()->
        {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个整数");
            counter.flag = sc.nextInt();
        });
        t2.start();
    }
}

本场景假设的情况，使用synchronized也能解决问题，只要给变量加锁，只不过没必要毕竟synchronized会大大降低效率

所以引出了volatile,相较于synchronized更轻量更高效(不涉及锁竞争，不涉及线程调度)

加入了volatile，给要访问的flag变量加上，此时线程1每次读取flag的值都必须强制从内存读取(牺牲一定的效率，确保了准确性)

volatile，在这种一个线程写，一个线程读的情况下，使用volatile就可以一定程度上保证线程安全，就不必要使用synchronized

13.对象等待集

协调多个线程之间执行的先后顺序

join保证两个线程按照一定的顺序来结束

对象等待集的应用场景

具体API：Object(Java中所有类的祖宗)

  • wait

  • notify

  • notifyAll

注意：

  1. wait、notify必须在synchronized中使用，如果不在synchronized中，此时直接使用就会抛异常

  2. 调用 wait/notify/加锁 都是要针对同一个对象进行

Monitor指的是监视器锁，也就是synchronized当前预期使获取到锁的状态才能调用wait，没写synchronized相当于还没获取到锁，久长时调用，于是就会出现问题

wait

三板斧

  1. 释放锁

  2. 等待其他线程的通知

  3. 等通知来了之后，重新尝试获取锁

notify唤醒

notify()通知某个线程被唤醒，从wait中醒来

notifyAll是唤醒所有线程

调用notify方法之后，代码并不会立即释放锁，而是在执行完当前的synchronized之后才释放锁

同时等待中的线程久长时重新竞争这个锁

image-20210808172803771

  1. 就绪队列

  2. WAITING状态队列

    1. 被调用wait的线程

  3. BLOCKED状态的队列

补充JUC——>CopyOnWriteArrayList

CopyOnWriteArrayList是线程安全的List

public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();

        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

点击并拖拽以移动

属于并发（JUC）编程领域

14.死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形

某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题

产生死锁的条件：

  1. 互斥条件：一个资源每次只能被一个进程使用

  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

  3. 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺

  4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

破解任一或多个条件就可以避免死锁发生

15.Lock锁

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具

锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

买票例子加锁

public class TestLock {
    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test).start();
        new Thread(test).start();
        new Thread(test).start();
    }
    }

class Test implements Runnable{
    int ticket = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{
                lock.lock();//加锁
                if(ticket > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticket--);
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }

        }
    }
}

点击并拖拽以移动

synchronized与lock对比

  • Lock是显式锁（手动开启和关闭锁，必须关闭）synchronized是隐式锁，出了作用域自动释放

  • Lock只有代码块锁，synchronized由代码块锁和方法锁

  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（上边说了synchronized不适合大的项目）–>Lock提供更多子类

  • 优先使用顺序：

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

16.线程协作-通信

单例模式

一种设计模式

在代码中有些对象之应该有一个实例，就成为”单例”

数据库的DataSource就是一个单例，多个方法都操作一个DataSource 实际开发中还有一些负责加载数据到内存的类，也应该是单例(往往要几个G几十个G)

单例模式相当于从语法角度，强制某个类只能由一个实例 单例模式的实现，主要依托于static关键字(被static修饰的成员，静态成员)

单例分类两个模式：

  1. 饿汉模式

    1. 实例创建出现在类加载阶段(第一次用到类就加载出来了)

    2. 吃完饭直接洗碗

  2. 懒汉模式

    1. 实例创建的时机是第一次使用，比饿汉模式更晚创建

    2. 吃完饭，先不洗，等下顿吃饭前再洗(而且下次用几个洗几个)

饿汉模式

public class TestThread8 {
    //饿汉模式
    //实例创建出现在类加载阶段(第一次用到类就加载出来了)
    //期待Singleton是一个单例类，只有一个实例
    static class Singleton{
        private static Singleton instance =new Singleton();
        public static Singleton getInstance(){
            return instance;
        }
        public static void setInstance(Singleton instance){
            Singleton.instance =  instance;
        }
        private Singleton(){}
    }

    public static void main(String[] args) {
        //只能通过getInstance的方式获取实例
        //而无法直接new对象创建Singleton
        Singleton s = Singleton.getInstance();
    }
}

不管用不用，只要用到实例了，就给你准备好对象了

懒汉模式——>一般更好

//懒汉模式
//实例创建的时机是第一次使用，比饿汉模式更晚创建
static class Singleton {
    private static Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null)
            instance = new Singleton();
        return instance;
    }
    private Singleton() { }
}

看起来懒汉模式更加高效，用到了才来占内存

针对单例模式的线程安全问题

饿汉vs懒汉哪个线程安全？

懒汉是安全的

LOAD——CMP——NEW——SAVE

如果已经有instance对象了

  • 懒汉看到了，就不会再new新的instance

  • 饿汉不会管，直接new instance就导致操作了多个instance对象，但实际上我们期望的是一个

但是并不绝对，其实还是不安全的

如何保证真正的线程安全？

加锁！！

如果把synchronized加到getInstance方法外面，这个时候针对判断，new，返回，三个操作都是串行的

如果把synchronized加到getInstance方法内部，这个时候针对 判断,new 加锁，返回操作时串行的

串行操作不如并发操作效率高

这样可以保证线程安全

image-20210810103832469image-20210810104121364

这样能够保证线程2的CMP操作一定在线程1之后

但是

这样就不能保证线程安全

image-20210810103915697image-20210810104526572

if判断没加锁，所以可能两个线程都读到了null，都去new对象了

所谓synchronized付出代价，具体体现在哪？

每次调用synchronized都会涉及到加锁解锁操作，这样并不科学

因为，一旦初始化完成就不需要再加锁了，所以只需要加锁一次，后面单纯读一下，并不涉及线程安全问题

只需要首次调用getInstance的时候要加锁，后续调用不必再加锁了，再加锁也是徒劳浪费时间

image-20210810105032177

所以针对上述例子，进行优化，只需要再加一层if判断

逻辑就很清晰了，过程类似体育比赛的初赛复赛制

  • 某线程来了，instance有了，不用进去加锁直接走

  • 某线程来了null，加锁，再null，new对象

image-20210810105901530

但此时也存在一个内存可见性问题

image-20210810110323325

所以再进行优化，针对内存可见性，一读一写的问题加上volatile

小结

线程安全的单例模式，涉及到的要点主要是：

  1. 加锁(再合适的位置加锁，保证吧if和new都包裹起来，同时也不要范围太大)

  2. 双重if(保证需要加锁的时候才加锁，一旦初始化完毕，就都是读操作了，就不必加锁了)

  3. volatile保证外层if读操作，读到的值都是内存中最新的值

阻塞队列

队列——>先进先出

阻塞：

  1. 这个队列是线程安全的(内部进行了加锁控制)

  2. 当队列满的时候，再去插入元素，就会阻塞，一直阻塞到队列不满的时候才会完成插入操作

  3. 当队列空的时候，从队列取元素，就会阻塞，一直阻塞到队列不空的时候才会完成取出操作

阻塞队列就引出了——>”生产者消费者模型”

意义；

一个服务器，同一时刻可能受到很多请求(到底收到多少请求不确定)，服务器处理请求能力是有限的，如果同一时刻服务器收请求过多，就挂了

Java标准库util中，已经提供了阻塞队列，BlockingQueue

image-20210810114648642

在concurrent包中，并发相关的工具类(JUC)

其本身是一个接口，不能被实例化

image-20210810114817844

public static void main(String[] args) throws InterruptedException {
    BlockingQueue<String> queue = new LinkedBlockingDeque<>();
    queue.put("hello");
    queue.take();
}

  • 阻塞队列的put、take方法都带有阻塞功能

  • 队列本身的方法offer、poll等功能并不带有阻塞功能

手动实现阻塞队列

消息队列——>比阻塞队列层次更高(了解)

也是一个阻塞队列，提供强大的功能

  1. 里面的数据是带有类型的topic 按照topic进行分类，把相同的topic的数据放到不同的队伍中，分别进行排队

    1. 一个消息队列，可以同时支撑多个业务的多组数据

  2. 往往是单独的服务器/服务器集群，通过网络通信的方式，进行”生产/消费”

  3. 还支持持久化存储(数据存在磁盘上)

  4. 消费的时候支持多种消费模式

    1. 指定位置消费(不一定只是取出队首元素)

    2. 镜像模式消费(一个数据可以被取多次，不是取一次直接就删除)

17.生产者消费者（问题）模式

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费

  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为之

  • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库再次放入产品为之

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件：

  • 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上同之消费者消费

  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费

  • 在生产者消费者问题中，仅有synvhronized是不够的

    • synchronized可阻止并发更新同一个共享资源，实现同步

    • synchronized不能用来实现不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题

方法名 作用
wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout) 指定等待的毫秒数
notify() 唤醒一个处于等待状态的线程
notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别搞得线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出illegalMonitorStateException异常

并发协作模型（生产者、消费者模式）——>管程法

生产者：负责生产数据的模块（可能是方法、对象、线程、进程）

消费者：负责处理数据的模块（可能是方法、对象、线程、进程）

缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

实例：吃鸡

//生产者消费者模式——>利用缓冲区解决：管程法
    //生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");

        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + container.pop().id + "只鸡");
        }
    }
}

//产品
class Chicken{
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count == 10){
            //通知消费者消费，生产暂停
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }


        //如果没满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        this.notifyAll();
        //可以通知消费者消费了

    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count == 0){
            //等待生产者生产，消费者等待
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        //吃完了，通知生产者生产
        return chicken;
    }

}

点击并拖拽以移动

并发协作模式（生产者、消费者模式）——>信号灯法

加一个标志位来判断

实例：看电视

//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }

}

//生产者——>演员
class Player extends Thread{
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2 == 0){
                this.tv.play("动漫播放中");
            }else{
                this.tv.play("抖音广告");
            }
        }
    }
}

//消费者——>观众
class Watcher extends Thread{
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品——>节目
class TV{
    //演员表演，观众等待
    //观众观看。演员等待
    String voice;
    boolean flg= true;

    //表演
    public synchronized void play(String voice) {
        if(!flg){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+ voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flg = !this.flg;

    }

    //观看
    public synchronized void watch() {
        if(flg){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了“"+voice);
        //通知演员表演
        this.notifyAll();
        this.flg = !this.flg;
    }

}

点击并拖拽以移动

18.线程池

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大

思路：提起按创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中

可以避免频繁创建销毁、实现重复利用

好处：

  • 提高响应速度（减少了创建新线程的时间）

  • 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）

  • 便于线程管理

    • corePoolSize：核心池的大小

    • maximumPoolSize：最大线程数

    • keepAliveTime:线程没有任务时最多保持多长时间后会终止

使用线程池

JDK5.0提供了线程池相关API：ExecutorService 和 Executors

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

  • void execute(Runnable command)：执行任务/命令。没有返回值，一般用来执行Runnable

  • Futuresubmit(Callabletask):执行任务，有返回值，一般用来执行Callable

  • void shutdown():关闭连接池

Excutors:工具类，线程池的工厂类，用于创建并返回不同类型的线程池

创建线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务,创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);//参数为线程池大小

        //这样就可以启动线程，不用start了
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());

    }

点击并拖拽以移动

总结

核心概念：

  • 线程就是独立的执行路径

  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程

  • main()称之为主线程，为系统的入口，用于执行整个程序

  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的

  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制

  • 线程会带来额外的开销，如CPU调度时间，并发控制开销

  • 每个线程在自己的公国内存监护，内存控制不当会造成数据不一致

进程（Process）代表运行中的的程序，一个运行的Java程序就是一个进程

操作系统的角度

  1. 线程（Thread）是进程中可独立执行的子任务

  2. 一个进程可以包含多个线程，同一个进程中的线程共享所申请到的资源（如内存空间、文件句柄等）

Java虚拟机的角度

  1. 线程是进程中的一个组件（Component），它可以看作执行Java代码的最小单位

  2. Java程序中任何一段代码总在某个确定的线程中执行

  3. Java虚拟机启动的时候会创建一个main线程，该线程负责执行Java程序的入口方法（main方法）

版权声明：本文为Wu-blogs原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Wu-blogs/p/15133093.html