• Java-多线程

    前言

    1、程序、进程、线程的基本概念

    • **程序(program)：**是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
    • **进程(process)：**是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程——生命周期。
      • 如：运行中的QQ、QQ音乐、杀毒软件等
      • 程序是静态的代码，进程是动态的(正在运行的代码)
      • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
    • **线程(thread)：**进程可进一步细化为线程，是一个程序内部的一条执行路径
      • 若一个进程同一时间并行执行多个线程，就是支持多线程的
      • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
      • 一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患
    • 单核CPU和多核CPU的理解
      • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他"挂起"(晾着他，等他想通了，准备好了钱，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来
      • 如果是多核的话，才能更好的发挥多线程的效率。
      • 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程
    • 并行与并发
      • 并行：多个CPU同时执行多个任务。比如：多个人同事做不同的事。
      • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

    2、使用多线程的优点

    • 提高应用程序的相应。对图形化界面更有意义，可增强用户体验
    • 提高计算机系统CPU的利用率
    • 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

    3、何时需要多线程

    • 程序需要同时执行两个或多个任务
    • 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
    • 需要一些后台运行的程序时

    4、线程的生命周期

    只有死亡/销毁，才是线程的最终状态，阻塞不是。下面方法可以在后面的常用方法演示中看到

    在这里插入图片描述

    1、创建线程的两种方式

    **注意：**所有线程皆是以start()方法运行，不是run()方法

    以下演示的是JDK刚开始就有的创建线程的两种方式继承Thread类和实现Runnable接口方式，后面会讲到使用JDK5.0新增的两种方式

    以下演示使用两个线程(主线程与自创线程)打印0-100之间的所有数

    为了方便观看，我们这里先使用Thread.currentThread().getName()方法，来获取当前线程的名称

    1.1、继承Thread类

    1. 在main方法中编写一个for循环，打印0-100的数

    2. 然后创建内部类MyDemo1，继承Thread类，并重写run()方法，然后在方法里面打印0-100以内的数

    3. 编写好后，在mian方法里创建MyDemo1对象，调用start()方法，让线程跑起来，查看结果

    4. 代码如下

      package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        MyDemo1 demo1 = new MyDemo1();
        demo1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}
class MyDemo1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23

    5. 结果：可以发现有两个线程在分别打印(主线程[main方法]的线程名称默认为main)

      在这里插入图片描述

    1.2、实现Runnable接口

    1. 第一步和上面的一样，先使用主线程打印一遍

    2. MyDemo1类不再继承Thread类了，改为implements Runnable接口

    3. 实现接口需要重写里面的run方法，内容和我们上面写的方法一样

    4. 启动线程步骤不一样，可以看如下main方法中的代码：

      package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        MyDemo1 demo1 = new MyDemo1();
        // 把实现了Runnable的类当做Thread的构造参数创建对象，然后调用start()方法，启动线程
        Thread t1 = new Thread(demo1);
        t1.start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}
class MyDemo1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    5. 结果：

      在这里插入图片描述

    1.3、简化版

    我们进入Runnable里面，可以看到类上面有@FunctionalInterface注解，代表了这个接口我们可以使用lamdba表达式来代替,我这里就不写简化的步骤了，直接写最终版(后面讲lamdba会详细讲解)

    package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }).start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    1.4、两者对比

    相同点

    1. 都可以用他们来创建线程

    2. 都是使用的Thread类的start方法来启动线程

    3. 点开Thread类可以发现，它自己也是实现了Runnable接口的

    不同点(Runnable的优点)
    1. 因为Java是单继承模式，所以继承Thread有局限性，不可以再继承其他类了。而implements可以多实现，扩展更好
    2. 使用继承方式，每次需要创建线程都需要重新new一个对象，每个线程都会拥有自己单独的一份属性。而使用实现方式，只需要new一个对象，所有线程都共享这个对象里的数据(章节1.5)会进行演示

    1.5、区别演示:

    下面演示的是售票窗口的案例，多个窗口(线程)共卖100张票的案例

    准备

    创建一个Window类(窗口)，，然后里面定义票(tickets)为100，再写一个方法，对票数进行–，并打印剩余票数

    class Window extends Thread{
    private int tickets = 100;

    @Override
    public void run() {
        while (true){
            if(tickets > 0){
                tickets--;
                // 因为是继承，所以this可以省略，Thread.currentThread().getName() == this.getName == 当前写的getName()
                System.out.println(getName() + ",当前剩余票数：" + tickets);
                
                // 因为是实现，跟Thread类没有任何关系，所以需要全部都写上
                // System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
            }else {
                break;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    (1)、Thread方式

    看完下面的步骤和结果再来看这，解决办法：

    1. 肯定就是使用继承Runnable接口的方式，下面会演示
    2. 把tickeds设置为静态属性，这样它就只会加载一次，每次new出来的对象都会共用同一个属性了

    运行

    public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.start();
        w2.start();
        w3.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    结果

    结果：(可以看到每个线程都有自己的100张票)，这样就是300张票了，不符合逻辑

    在这里插入图片描述

    (2)、Runnable方式

    在执行的时候，可能会有重票的概率，效果如下，现在不用在意，下面第三章中会详细讲到解决办法

    在这里插入图片描述

    运行

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    结果

    在这里插入图片描述

    2、线程的常用方法

    2.1、start()

    void start()：启动线程，并执行对象的run()方法。上面都是使用的start()启动线程，这里就不演示了

    2.2、run()

    void run()：线程在被调度时执行的操作。就是上面继承以后重写的run()方法，如果没重写，则什么也不执行

    2.3、getName()

    String getName()：返回线程的名称，继承方式直接调用即可

    public class Test{
    public static void main(String[] args) {
        Window window = new Window();
        System.out.println(window.getName()); // Thread-0


    }
}
class Window extends Thread{
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2.4、setName()

    void setName()：修改当前线程的名称，继承方式直接调用即可

    public class Test{
    public static void main(String[] args) {
        Window window = new Window();
        System.out.println(window.getName()); // Thread-0

        window.setName("MyThread");
        System.out.println(window.getName()); // MyThread
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.5、currentThread()

    Thread currentThread()：返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类

    public class Test{
    public static void main(String[] args) {
        Window w = new Window();
        w.start();
        System.out.println(Thread.currentThread().getName()); // main
    }
}
class Window extends Thread{
    @Override
    public void run() {
        System.out.println("getName：" + getName()); // getName：Thread-0
        System.out.println("currentThread().getName()：" + Thread.currentThread().getName()); // currentThread().getName()：Thread-0
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.6、yield()

    static void yield()：线程让步

    • 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
    • 若队列中没有同优先级的线程，忽略此方法

    设置线程优先级

    • 范围0-10，默认为5

      • public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5; 
public final static int MAX_PRIORITY = 10;

        • 1
        • 2
        • 3
    

    • 1
    • 设置线程优先级：setPriority(int newPriority)
    • 获得线程优先级：getPriority()

    查看结果可以看到大部分几率是在打印到main：20的时候，下面就开始打印Thread-0线程的东西了。也有部分情况：在礼让之后，自己又被分配到继续执行了

    

    • 1
    package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w = new Window();
        // 需要在启动前设置
        w.setPriority(Thread.MAX_PRIORITY);
        w.start();
        
        Thread thread = Thread.currentThread();
        thread.setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            System.out.println(thread.getName() + "：" + i);
            if(i == 20){
                Thread.yield();
            }
        }

    }
}
class Window extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：" + i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    2.7、join()

    void join()：当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法假如的join线程执行完为止

    • 低优先级的线程也可以获得执行

    查看结果可以看到大部分几率是在打印到main：20的时候，下面就开始打印Thread-0线程的东西了。也有部分情况：在礼让之后，自己又被分配到继续执行了

    package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w = new Window();
        // 需要在启动前设置
        w.setPriority(Thread.MAX_PRIORITY);
        w.start();

        Thread thread = Thread.currentThread();
        thread.setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            System.out.println(thread.getName() + "：" + i);
            if(i == 20){
                try {
                    w.join(); // 主线程被阻塞，Thread-0线程插入
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Window extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：" + i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    2.8、sleep(long millis)

    static sleep(long millis)：

    public class Test{
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            if(i == 20){
                System.out.println(LocalTime.now()); // 17:55:21.554
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(LocalTime.now());// 17:55:23.562
            }
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.9、stop()

    强制线程生命周期结束，不推荐使用(@Deprecated)，和下面案例结合来讲

    2.10、isAlive()

    boolean isAlive()：判断线程是否还活着，如果已经死亡，则错误

    public class Test{
    public static void main(String[] args) {
        Window window = new Window();
        window.start();
    }
}
class Window extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：" + i);
            if(i == 20){
                System.out.println(i); // 20
                System.out.println(isAlive()); // true
                stop();
                System.out.println(isAlive()); // 无结果
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    3、线程的安全问题与使用问题

    3.1、问题回显

    还是用上面的那个售票案例，三个窗口(线程)同卖100张票。这是使用两种方法创建线程都可以，我这里使用继承方式了。

    代码
    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    @Override
    public void run() {
        while (true){
            if(tickets > 0){
                tickets--;
                System.out.println(getName() + ",当前剩余票数：" + tickets);
            }else {
                break;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    结果

    可以看到有重票的概率，这就是线程安全问题

    在这里插入图片描述

    原理

    在线程-0执行完–方法后,值为99，阻塞了，没有打印tickets。然后线程-1也进来了，也执行完–方法后98，这时候线程-0也取消阻塞了，然后两个线程都会同时打印98

    在这里插入图片描述

    3.2、synchronized关键字(解决问题)

    语法：synchronized(同步监视器){

    ​ // 需要被同步的代码块

    }

    说明：

    • 操作共享数据的代码，即为需要被同步的代码
    • 共享数据，多个线程共同操作的变量。比如：tickets就是共享数据
    • 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁

    所有线程必须共用同一把锁才有用，在继承Thread类上有体现

    3.2.1、同步代码块

    (1)、在继承Thread类的情况上使用

    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;
    /*
    	 不能这么写
    	 因为使用继承方式，会创建三个Window对象，三个线程就会拥有三把自己的锁，无效，所有线程必须共用同一把锁才有用
    */
    // private Object object = new Object();
    private static Object object = new Object();

    @Override
    public void run() {
        while (true){
            // 这里需要一个对象充当锁，我这里就在类里面建一个object属性充当
            synchronized (object){
                if(tickets > 0){
                    tickets--;
                    System.out.println(getName() + ",当前剩余票数：" + tickets);
                }else {
                    break;
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    结果：没有任何线程安全问题

    在这里插入图片描述

    (2)、在实现Runnable的情况上使用

    这种方式和上面一样，惟一的区别就是，属性不需要设置为static了，因为只会创建一个对象

    3.2.2、同步方法

    语法：private synchronized void saleTicket()

    使用同步方法的话是不需要你自己定义同步监视器的，会使用Java默认的，具体原因会在3.3章中介绍

    (1)、在继承Thread类的情况上使用

    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    @Override
    public void run() {
        while (true){
            this.saleTicket();
        }
    }

    // 如果我们对共享数据的操作在一个方法里面，就可以直接在方法上加synchronized关键字即可
    // 这么写不是不需要同步监视器，而是java使用了默认的同步监视器，这样就不用考虑哪种方式创建的多线程了
    private synchronized void saleTicket(){
        if(tickets > 0){
            tickets--;
            System.out.println(getName() + ",当前剩余票数：" + tickets);
        }
        // 方法里面就不写break了，可自行关闭程序
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    结果：没有任何问题

    在这里插入图片描述

    (2)、在实现Runnable的情况上使用

    这个和上面继承一模一样的，都不需要写static，具体原因会在3.3章讲到，java的默认的同步监视器

    3.3、同步监视器的简单参数

    3.3.1、同步代码块的简单参数

    我们在上面使用同步监视器，是自己在类中定义的Object类，并且继承方式的话还要声明为静态的。

    如果说我们不想每次都自己定义一个类来充当锁，而是直接写一个值就可以，当然可以，如下

    this

    适用于实现Runnable接口，因为我们只需要创建一个对象，这个this就指向的当前创建的这个对象

    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        new Thread(w1).start();
        new Thread(w1).start();
        new Thread(w1).start();
        /*Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();*/
    }
}
class Window implements Runnable{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    @Override
    public void run() {
        while (true){
            // 这个this就指向的上面创建w1对象，只创建了一次，所以也是所有线程共享同一把锁
            synchronized (this){
                if(tickets > 0){
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
                }else {
                    break;
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    结果：没有任何问题

    在这里插入图片描述

    类名.class

    两种方法创建线程的方式都适用

    原因是类也是一个类–Class类，只会被系统加载一次，所以也可以充当锁，具体会在后面讲反射的时候讲到Class类

    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    @Override
    public void run() {
        while (true){
            // 当前这个类充当锁
            synchronized (Window.class){
                if(tickets > 0){
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
                }else {
                    break;
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    3.3.2、同步方法的默认参数理解

    我们上面看到，同步方法是直接写在方法上的，所以不需要我们写同步监视器，但是并不代表它没有。

    当我们使用实现方式创建的线程，那它默认就是this，如果我们使用的是继承的方式，那它默认就是类名.class

    3.4、synchronized原理

    在这里插入图片描述

    3.5、Lock接口(解决问题)

    • 从JDK5.0开始，Java提供了更强大的线程同步机制———通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
    • Java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
    • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
    package com.tcc.test;

import java.time.LocalTime;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.start();
        w2.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    // 1.实例化ReentrantLock，继承方式需要定义为static，多线程共享同一把锁
    private static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            // 最好放到try，finally里面，因为怕里面代码异常，锁不被打开
            try {
                // 2.调用lock()
                lock.lock();
                if(tickets > 0){
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
                }else {
                    break;
                }
            }finally {
                // 3. 释放锁
                lock.unlock();
            }
                
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    结果：没有任何问题

    在这里插入图片描述

    3.6、synchronized与Lock的区别

    相同点
    • 两者都可以解决线程安全问题
    不同点
    • Lock是显式锁(手动开启和关闭锁，别忘记关锁！)，synchronized是隐式锁，出了作用域自动释放
    • Lock只有代码块锁，synchronized有代码块锁和方法所
    • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
    优先使用顺序

    Lock->同步代码块(已经进入了方法体，分配了相应资源)->同步方法(在方法体之外)

    3.7、锁使用问题

    1. 多个线程必须共享同一把锁(上面有讲到，使用继承方式，同步监视器必须定义为static的，否则多个线程会有多个锁)

    2. 使用synchronized的时候，不论是同步代码块或同步方法，都不能多包({xxx})，或者少包内容

      1. 案例

        package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w2.start();
        w1.start();
        w3.start();
    }
}
class Window extends Thread{
    // 使用静态属性，解决继承下三个线程卖300张票问题
    private static int tickets = 100;

    @Override
    public void run() {
        // 当线程进去后，就会进入无限循环，直到执行完毕，然后才释放锁，其他线程一进去,tickets以及=0了，就不执行了
        synchronized (Window.class){
            while (true){
                if(tickets > 0){
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + ",当前剩余票数：" + tickets);
                }else {
                    break;
                }
            }
        }
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37

      2. 以上案例，如果把while(true)也包在了里面，则多线程就无效了，只有一个线程全部执行完毕

    3. 线程的死锁

      1. 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
      2. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

    4. 解决办法

      1. 专门的算法、原则
      2. 尽量减少同步资源的定义
      3. 尽量避免嵌套同步
    演示
    package com.tcc.test;

import java.time.LocalTime;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        W1 w1 = new W1();
        W2 w2 = new W2();
        w1.start();
        w2.start();
    }
}
class W1 extends Thread{
    @Override
    public void run() {
        synchronized (W2.class){
            System.out.println(getName() + "：进去了，打开了W2的锁-1");
            // 为了增加死锁的概率
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (W1.class){
                System.out.println(getName() + "：进去了，打开了W1的锁-2");
            }
            System.out.println(getName() + "：出来了，关闭了W1的锁");
        }
        System.out.println(getName() + "：出来了，关闭了W2的锁");
    }
}
class W2 extends Thread{
    @Override
    public void run() {
        synchronized (W1.class){
            System.out.println(getName() + "：进去了，打开了W1的锁-1");
            synchronized (W2.class){
                System.out.println(getName() + "：进去了，打开了W2的锁");
            }
            System.out.println(getName() + "：出来了，关闭了W2的锁");
        }
        System.out.println(getName() + "：出来了，关闭了W1的锁");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    结果：

    线程-0进去了->打开了w2的锁 线程-0等待w1的锁打开后进入

    线程-1进去了->打开了w1的锁 线程-1等待w2的锁打开后进入

    谁也不让谁，然后就形成了死锁问题

    在这里插入图片描述

    4、线程的通信

    线程的通信就是指线程与线程之间的交替执行

    实现线程通信主要有三个方法(定义在Object类中的)

    • wait()：让线程处于等待状态**(同时释放同步监视器)**
    • notify()：唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级最高的
    • notifyAll()：和notify功能一样，都是解除线程的等待，区别是唤醒所有被wait的线程

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

    使用

    package com.tcc.test;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        new W1().start();
        new W1().start();
    }
}
class W1 extends Thread {
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            synchronized (W1.class){
                // 解除当前线程的等待状态
                W1.class.notify();
                if(ticket > 0){
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "：当前票数：" + ticket);
                    try {
                        // 执行完毕后，当前线程进入等待状态，直到下一个线程进入
                        W1.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    结果

    在这里插入图片描述

    4.1、sleep和wait的异同

    相同
    • 执行方法，都可以让线程进入阻塞状态
    不同
    • 两个方法声明的位置不同。
      • Thread类中生命sleep()
      • Object类中生命wait()
    • 调用要求不同
      • sleep()可以在任何需要的场景下调用。
      • wait()必须使用在同步方法或同步代码块中

    5、JDK5新增创建线程方式

    5.1、实现Callable接口(可接收返回值)

    与使用Runnable相比，Callable功能更强大些

    • 相比run()方法，可以有返回值
    • 方法可以抛出异常
    • 支持泛型的返回值
    • 需要借助FutureTask类，比如获取返回结果

    Future接口

    • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
    • FutureTask是Future接口的唯一实现类
    • FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

    Callable接口是支持泛型的，如果写了泛型，则返回值为泛型类型，后面获取返回值无需做强转操作

    使用

    package com.tcc.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args){
        // 3. 创建实现了Callable接口的对象
        Window w = new Window();

        // 4. 把创建好的对象传递给FutureTask类的构造函数中
        FutureTask futureTask = new FutureTask<>(w);
        // 如果是使用的implements Runnable方法创建的对象，则使用如下方式带入返回值
//        FutureTask futureTask = new FutureTask<>(w,"123");

        // 5. 因为FutureTask实现了RunnableFuture，而它又继承了Runnable，所以可以当做参数传入，启动线程
        new Thread(futureTask).start();

        try {
            // 6. 线程运行完后，通过get()方法获取线程执行完毕后返回的结果
            Object o = futureTask.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
        	// 记住要关闭线程池
            service.shutdown();
        }
    }
}
// 1. 继承Callable类
// Callable是支持泛型的，如果写了泛型，则返回值为泛型类型，后面获取返回值无需做强转操作
class Window implements Callable {

    // 2. 重写Callable接口的call方法，可以接收Object类型的返回值
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
        return "我执行完了";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    结果

    在这里插入图片描述

    5.2、线程池(常用)

    • 背景
      • 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
    • 思路
      • 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
    • 好处
      • 提高响应速度(减少创建新线程的时间)
      • 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
      • 便于线程管理
        • corePoolSize：核心池的大小
        • maximumPoolSize：最大线程数
        • keepAliveTime：线程没有任务时最多保持多长时间后悔终止
        • …
    5.2.1、线程池相关API

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

    ExecutorService：真正的线程池接口。常见子类ThreadProolExecutor

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

    Executors：工具类、线程池的工具类，用于创建并返回不同类型的线程池

    • Executors.newCachedThreadProol()：创建一个可根据需要创建新线程的线程池
    • Executors.newFixedThreadProol(n)：创建一个可重用固定线程数的线程池
    • Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
    • Executors.newScheduledThreadProol(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

    Executors创建线程池可能造成很多潜在问题，具体可以查看：https://blog.csdn.net/qq_42764468/article/details/123373042，尽量使用ThreadPoolExecutor来创建线程池，后面会出一个讲解线程池的文章

    本次拿第二个创建指定数量的线程池举例

    使用

    package com.tcc.test;

import java.util.concurrent.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args){
        // 创建一个执行线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(8);
        // 适用于实现Runnable接口的方式
        // service.execute(Runnable command);

        // 适用于实现Callable接口的方式
        Future submit = service.submit(new Window());
        try {
            Object o = submit.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
// 1. 继承Callable类
class Window implements Callable {

    // 2. 重写Callable接口的call方法，可以接收Object类型的返回值
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
        return "我执行完了";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    结果

    在这里插入图片描述

  • 相关阅读:
    WebServer 解析HTTP 响应报文
    集成驱动器LMG3411R150RWHR GaN FET(LMG3410R150RWHR)
    FPGA project : usrt_rs232
    智慧安防视频监控系统EasyCVR平台突然运行异常，是什么原因？
    MARKLLM——LLM 水印开源工具包
    课题学习(五)----阅读论文《抗差自适应滤波的导向钻具动态姿态测量方法》
    Solidity 小白教程：18. Import
    SpringMVC处理请求核心流程
    引擎之旅 Chapter.4 日志系统
    SpringSecurity 5.7.3中使用withObjectPostProcessor遇到的配置无效问题
  • 原文地址：https://blog.csdn.net/qq_57404736/article/details/127836847