• Java 多线程

    目录

    线程相关概念

    • 程序(program)
      是为完成特定任务、用某种语言编写的一组指令的集合（简单说就是写的代码）。
    • 进程
      1、进程是指运行中的程序，比如使用的QQ，就启动了一个进程，操作系统会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将会为迅雷分配新的内存空间。
      2、进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。
    • 线程
      1、线程是由进程创建的，是进程的一个实体；
      2、一个进程可以拥有多个线程，就比如迅雷可以同时（包括并发和并行）下载多个文件。
    • 其他相关概念
      1、单线程：同一个时刻，只允许执行一个线程；
      2、多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件；
      3、并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的感觉，简单的说，单核cpu实现的多任务就是并发。
      在这里插入图片描述
      4、并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
      在这里插入图片描述
      注： 并发和并行可能同时存在。

    小结：一个CPU在同时执行多个任务就叫并发；多个CPU执行不同的任务就是并行。而并行过程中也可以有CPU在执行多个任务，此时即并发和并行是并存的

    • 用代码查看电脑有多少个cpu核
    package com.hspedu;

/**
 * @author 韩顺平
 * @version 1.0
 */

public class CpuNum {
    public static void main(String[] args) {

        Runtime runtime = Runtime.getRuntime();
        //获取当前电脑的cpu数量/核心数
        int cpuNums = runtime.availableProcessors();
        System.out.println("当前有cpu 个数=" + cpuNums);


    }
}


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

    线程基本使用

    • 创建线程的两种方式
      在 Java 中线程的使用有两种方法
      1.继承 Thread 类，重写 run 方法
      2.实现 Runnable 接口，重写 run 方法
      在这里插入图片描述

    1.继承 Thread 类，重写 run 方法

    在这里插入图片描述

    示例代码

    package com.hspedu.threaduse;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示通过继承Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {

        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        //老韩读源码
        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是native(本地)方法，是JVM调用, 底层是c/c++实现
            //这里其实是具有多线程机制的 start0() 方法来调用了我们重写的 run 方法
            //真正实现多线程的效果， 是start0(), 而不是 run
            private native void start0();

         */

        cat.start();//启动线程-> 最终会执行cat的run方法



        //cat.run();//run方法就是一个普通的方法, 并没有真正的启动一个线程，就会把run方法执行完毕，才向下执行（相当于此时就是一个串行化的执行，那么在这里就会出现阻塞）
        //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行..
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字默认就是main
        for(int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }

    }
}

//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */



class Cat extends Thread {

    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}


    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    程序示意图

    在这里插入图片描述

    在main里面建立一个循环，此时main内的循环会和main建立的Thread0线程交替执行（如果是单核就并发/如果是多核就并行），进程可以创建线程，线程也可以创建线程。

    2.实现 Runnable 接口，重写 run 方法

    • 说明
      Java是单继承的，在某些情况下一个类可能已经继承了某一个父类，这时候如果想要创建线程只能通过实现Runnable接口来创建了。
      在这里插入图片描述

    示例代码

    package com.hspedu.threaduse;

/**
 * @author 韩顺平
 * @version 1.0
 * 通过实现接口Runnable 来开发线程
 */
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); 这里不能调用start
        //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();

//        Tiger tiger = new Tiger();//实现了 Runnable
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        threadProxy.start();
    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    } 
}

//线程代理类 , 模拟了一个极简的Thread类(为了更好的理解代理模式)
class ThreadProxy implements Runnable {//你可以把ThreadProxy类当做 ThreadProxy

    private Runnable target = null;//属性，类型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//这个方法时真正实现多线程方法
    }

    public void start0() {
        run();
    }
}


class Dog implements Runnable { //通过实现Runnable接口，开发线程

    int count = 0;

    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 10) {
                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
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    实现 Runnable 接口来创建线程：这里底层使用了设计模式[ 代理模式 ] = > 为了更好的理解：上面代码中即模拟 实现Runnable 接口 开发线程的机制（其实就相当于写了个 简易版的 Tread类）

    *应用案例

    在这里插入图片描述

    代码

    package com.hspedu.threaduse;

/**
 * @author 韩顺平
 * @version 1.0
 * main线程启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {

        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();//启动第1个线程
        thread2.start();//启动第2个线程
        //...

    }
}

class T1 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        while (true) {
            //每隔1秒输出 “hello,world”,输出10次
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 60) {
                break;
            }
        }
    }
}

class T2 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        //每隔1秒输出 “hi”,输出5次
        while (true) {
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 50) {
                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
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    理解

    在这里插入图片描述

    3.继承Thread vs 实现Runnable 的区别

    1、从Java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，因为从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
    2、实现Runnable接口方式更适合多个线程共享一个资源的情况，并且避免了单继承限制。（无特殊要求，建议使用实现 Runnable 接口的方式去创建线程）如，下图中thread01，thread02(多线程)共享t3(一个资源)
    在这里插入图片描述

    4.多线程售票问题引出同步互斥问题

    代码：

    package com.hspedu.ticket;

/**
 * @author 韩顺平
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试 继承 Thread 类实现创建线程
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


        System.out.println("===使用实现接口方式来售票=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口


    }
}


//使用Thread方式

class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}



//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;
    //让多个线程共享 ticketNum
    // 由于只创建 一个 SellTicket02 对象放入三个线程中，所以这三个线程用的是同一个 ticketNum，即对象 sellTicket02 的 ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}


    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93

    5.线程终止

    • 基本说明
      1.当线程完成任务后，会自动退出
      2.还可以通过在其他方法内使用变量来控制run方法退出的方式停止线程，即通知方式（不一定非要在main()内方法去控制，也可以是在一个线程的某个方法中的变量控制另一个线程的run方法）
      在这里插入图片描述

    在这里插入图片描述

    代码

    package com.hspedu.exit_;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式

        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {

            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}



    • 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

    示意图

    在这里插入图片描述

    线程常用方法

    第一组

    （1）setName //设置线程名称，使其与参数name相同；

    （2）getName //返回该线程的名称；

    （3）start //使该线程开始执行；Java虚拟机底层调用该线程的start0方法；

    （4）run //调用线程对象run方法；

    （5）setPriority //更改线程的优先级；

    （6）getPriority //获取线程的优先级；
    【这里所谓的优先级并不是指线程执行的顺序，一般可认为是CPU时间片的分配大小。并不是说优先级大的线程就先执行，只不过优先级高的线程获取CPU资源的概率较大而已。且由于Java线程是通过映射到系统的原生线程上来实现的，所以线程的调度最终还是取决于操作系统，操作系统的优先级与Java的优先级并不一一对应，如下图。】
    在这里插入图片描述
    【更重要的是，其实操作系统可以完全不用理会Java线程对于优先级的设定。就算采纳Java线程对于优先级的设定，也可能有很多其他情况，如：优先级可能会被系统自动改变，比如Windows系统中就存在一个优先级推进器，大致功能就是如果一个线程执行的次数过多的话，可能会越过优先级为他分配执行时间】

    （7）sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；【线程的静态方法，使当前线程休眠】

    （8）interrupt //中断线程，注意不是终止，如果线程正在休眠，则停止休眠，继续执行。
    【 当一个线程调用了interrupt方法后，如果该线程处于阻塞状态（如等待I/O、等待获取锁、等待进入synchronized块等），那么该线程会立即抛出InterruptedException异常并退出阻塞状态；如果该线程没有处于阻塞状态，那么该线程会继续执行直到下一次检查中断状态时才会退出 】

    • 注意事项和细节
      （1）start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程；
      （2）线程优先级的范围；
      在这里插入图片描述
      （3）interrupt，中断线程，但没有真正的结束线程，所以一般用于中断正在休眠的线程；
      （4）sleep：线程的静态方法，使当前线程休眠。

    示例代码

    package com.hspedu.method;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("老韩");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程


        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for(int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1

        t.interrupt();//当执行到这里，就会中断 t线程的休眠.



    }
}

class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}



    • 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
    • 51

    第二组

    （1）yield：线程的礼让
    是一个静态原生态(static native)方法。让出CPU，让其他线程执行，但是礼让的时间不确定，所以不一定礼让成功。【① Thread类中有一个方法叫做yield()，作用在于实现线程的礼让，即多个线程一块跑，某个线程礼让的话，就是让这个线程由运行状态进入就绪状态，让CPU重新调度。需要注意的是，因为是让线程从运行状态进入就绪状态，让CPU重新调度，那么该线程可能还是会进入运行状态，所以礼让不一定成功。】【② 是否礼让成功已经涉及到内核态了，即已经到操作系统的底层由CPU来决定，因此不一定成功。如这样一种情况：此时资源并不紧张，只有两个线程：T1和T2，此时CPU正在执行T1但T1调用yield方法进行礼让，但CPU认为此时它的资源并不紧张，T2也不是特别耗费时间，CPU来回切换既可以照顾到T1，也可以照顾到T2，那么此时线程提出的“礼让”就不一定会成功】【③ “礼让”在资源紧张的时候成功的可能性会更高】
    （2）join：线程的插队
    插队的线程一旦插队成功，则 肯定先执行完插入的线程所有的任务。如下图。【join()方法的作用在于，如果在某个线程A中，另外一个线程B调用join()方法后，那么A需要在B执行完成之后，才可以继续执行任务。此时A线程的状态由运行态变为阻塞态。另外，我们亦可以设置一个超时时间，让等待的线程最多等待多少秒就不等了。 如果设置0s，则代表永远等下去，直到插队的线程运行结束。在jdk源码中join()无参方法调用的即是join(0)，代表永远等待，直到运行结束，源码如下。】
    在这里插入图片描述

    
    // Waits for this thread to die.
   
    public final void join() throws InterruptedException {
        join(0);
    }
/**
     * Waits at most {@code millis} milliseconds for this thread to 
     * die. A timeout of {@code 0} means to wait forever.
     *
**/
    public final synchronized void join(long millis)
    throws InterruptedException {
    ....
    }


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

    示例代码

    在这里插入图片描述

    package com.hspedu.method;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("子线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + 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
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    用户线程和守护线程

    1.用户线程：也叫工作线程，当线程的任务执行完或通知方式通知它结束
    2.守护线程：一般是为了工作线程服务的，当所有的用户线程结束，守护线程自动结束
    3.常见的守护线程：垃圾回收机制

    示例代码

    package com.hspedu.method;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //,只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        // Daemon 译为“守护线程”
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
        }
    }
}



    • 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

    简单地说，守护线程就是当所有的其他用户线程都退出了，它也就自动退出了。即尽管在其他线程内没有通知守护线程退出，但它会由线程的机制来控制，它发现此刻已经没有其他的线程需要它来守护了，那么它就结束了
    守护线程的用处：将来涉及多线程时，可以使用守护线程来监控其他的线程或者获取其他线程的信息，这样做就利于我们管理多线程

    线程的生命周期

    目前对线程生命周期有不同说法，分别将其分为5、6、7种状态，下面分别对这3种情况进行介绍：

    我们首先来看一下JDK种用Thread.State枚举表示了线程的6种状态，如下图。
    在这里插入图片描述而7种状态则是基于6种状态中将RUNNABLE又细分成了Ready(就绪状态)和Running(运行状态)，如下图。（重点！！！）
    在这里插入图片描述

    也就是说若是分为6种状态，那么其中Runnable状态代表可运行状态，但是它是否真的运行取决于内核中的调度器。因此在分为7种状态时，将这部分细化成了两种状态：一种叫Ready(就绪状态)，即已准备好了但还没运行；另一种叫Running(运行状态)，即真正持有或占有CPU资源的一种状态

    • 其他状态
      Waiting状态：等待插队进来的t执行完成，A再执行
      TimedWating:超时等待，比如sleep(10000),当执行到这一句，线程进入TimeWating状态
      Blocked：获得一把锁或者进入同步代码块的时候进入这个状态。阻塞状态如果又获得这把锁，又进入Runnable状态

    最后一种情况是仅分为5种状态，如下图。
    在这里插入图片描述

    将线程分为5种状态时，分别有：创建、就绪、运行、阻塞和死亡（即省略了等待及超时等待这两种状态）
    1.创建状态（New 状态）：
    生成线程对象，并没有调用该对象的start方法。
    2.就绪状态：（可运行状态）
      2.1、调用了线程对象的start方法之后，即进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。
      2.2、在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
    3.运行状态：
    线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
    4.阻塞状态；
    线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。
    sleep,suspend,wait等方法都可以导致线程阻塞。
    5.死亡状态：
    如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。
    对于已经死亡的线程，无法再使用start方法令其进入就绪状态。

    以JDK的6种状态为基础的示例代码

    package com.hspedu.state_;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }

        System.out.println(t.getName() + " 状态 " + t.getState());

    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            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

    Synchronized

    • 线程同步机制
      1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性；
      2.也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直至该线程完成操作，其他线程才能对该内存地址进行操作。
    • 同步具体方法-Synchronized
      1.同步代码块
      synchronized（对象）{ //得到对象的锁，才能操作同步代码
                   //需要被同步的代码
      }
      2.同步方法：synchronized还可以放在方法声明中，表示整个方法为同步方法。
      public synchronized void m（String name）{
                   //需要被同步的代码
      }

    同步机制

    【Kim】操作系统知识点回顾：同步 指在不同进程之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。如果用对资源的访问来定义的话，同步是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

    示例代码(解决4.多线程售票问题)

    package com.hspedu.syn;

/**
 * @author 韩顺平
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object object = new Object();


    //同步方法（静态的）的锁为当前类本身
    //老韩解读
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //老韩说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法

synchronized         (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell方法是一个同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @Override
    public void run() {


        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}


    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163

    互斥锁

    【Kim】操作系统知识点回顾：互斥 指散布在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。如果用对资源的访问来定义的话，互斥某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

    • 基本介绍
      （1）Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性；
      （2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象；（这是是从它底层操作系统层面来保证的）
      （3）关键字 synchronized 用来与对象的互斥锁联系，当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问；（即实际上用关键字 synchronized 修饰某个对象就代表在这个对象上加锁了）
      （4）同步的局限性：导致程序的执行效率要降低；
      （5）同步方法（非静态的）的锁可以是this，也可以是其他对象（但是要求多个线程操作的一定要是同一个对象）；【非静态的同步方法只适用于通过实现接口创建的线程，因为若是通过继承类实现的线程那么在创建多个线程时操作的就是不同的对象了，而我们要求多个线程操作的必须是同一个对象】
      （6）同步方法（静态的）的锁为当前类本身。【静态同步方法适用于通过继承类创建的线程，也适用于通过实现接口创建的线程】

    示例代码

    package com.hspedu.syn;

/**
 * @author 韩顺平
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object object = new Object();


    //同步方法（静态的）的锁为当前类本身
    //老韩解读
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {// 锁加在类上
            System.out.println("m2");
        }
    }

    //老韩说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法

        synchronized (/*this*/ object) {// 互斥锁也可以加在其他对象上，只要所有线程的锁对象是同一个就行!!!!!!!!!
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();//sell方法是一共同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @Override
    public void run() {


        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}


    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 注意事项和细节
      （1）同步方法如果没有使用static修饰：默认锁对象为this；
      （2）如果方法使用static修饰：默认锁对象为当前类.class
      （3）实现的落地步骤：
            ① 需要先分析上锁的代码；
            ② 无特殊情况，优选同步代码块或者同步方法；【范围小，效率高】
            ③ 要求多个线程的锁对象为同一个！！！

    死锁

    【Kim】操作系统知识点回顾：死锁： 如果一组进程中的每一个进程都在等待仅由该组进程中的其他进程才能引发的事件，那么该组进程就是死锁的。或者在两个或多个并发进程中，如果每个进程持有某种资源而又都等待别的进程释放它或它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组进程产生了死锁。通俗地讲，就是两个或多个进程被无限期地阻塞、相互等待的一种状态。
    死锁产生的4个必要条件 ⭐
    　　产生死锁必须同时满足一下四个条件，只要其中任一条件不成立，死锁就不会发生。
    ① 互斥条件 (Mutual exclusion)：资源不能被共享，只能由一个进程使用。
    ② 请求与保持条件 (Hold and wait)：已经得到资源的进程可以再次申请新的资源。
    ③ 非抢占条件 (No pre-emption)：已经分配的资源不能从相应的进程中被强制地剥夺。
    ④ 循环等待条件 (Circular wait)：系统中若干进程组成环路，该环路中每个进程都在等待相邻进程正占用的资源。

    • 基本介绍
      多个线程都占用了对方的资源，都不肯相让，导致了死锁，在编程时一定要避免死锁的发生。

    模拟死锁-示例代码

    package com.hspedu.syn;

/**
 * @author 韩顺平
 * @version 1.0
 * 模拟线程死锁
 */
public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}


//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
                
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}



    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58

    释放锁

    • 下面操作会释放锁
      （1）当前线程的同步方法、同步代码块执行结束；
          案例：上厕所，完事出来
      （2）当前线程在同步代码块、同步方法中遇到break、return；
          案例：没有正常的完事，经理叫他修改bug，不得已出来
      （3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束；
          案例：没有正常的完事，发现忘带纸，不得已出来
      （4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程停止，并释放锁。
          案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去
    • 下面操作不会释放锁
      （1）线程执行同步代码块或同步方法时，程序调用Thread.sleep()，Thread.yield()方法暂停当前线程的执行，不会释放锁；
          案例：上厕所，太困了，在坑位上眯了一会
      （2）线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
      【提示：不推荐使用suspend()和resume()来控制线程，在idea中可以看到这两个方法已经被设定为了过时方法。（“Thread类的suspend()方法使线程无法运行到等待状态。如果要停止线程执行并在发生特定事件时再次启动,则使用此方法。 此方法允许线程暂时停止执行。 可以使用resume()方法恢复挂起的线程。” ）】
      在这里插入图片描述


    补充-Kim的疑惑🧐： join()方法与锁的释放

    先说结论：join()方法只会释放被调用线程的对象锁

    【前提：两种情景均在两个线程中设置了两个同步代码块，且这两个线程中同步代码块用的是同一个对象锁才能达到同步的效果】

    • 情景一：String对象被上锁，锁为String的对象锁
    package cn.alan.threadState;
 
//测试插队线程
public class TestJoin implements Runnable{
    String hello;
 
    public TestJoin(String hello) {
        this.hello = hello;
    }
 
    @Override
    public void run() {
        synchronized (hello){
            for (int i = 0; i < 5; i++) {
                System.out.println("插队线程执行" + hello);
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        String hello = "hello";
 
        //启动插队线程
        Thread thread = new Thread(new TestJoin(hello));
        thread.start();
 
        synchronized (hello){
            //主线程
            for (int i = 0; i < 10; i++) {
                if (i==5){
                    thread.join();
                }
                System.out.println("主线程执行" + hello);
            }
        }
 
    }
}

    • 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

    在这里插入图片描述

    说明：当我们进入main方法中的同步块时，其main线程首先获取到了hello字符串上的锁，因此继续执行。当执行到 i==5 时，应该执行 thread.join(); 这条语句，但由于hello字符串上的锁已被main线程获取，且 join() 方法无法打开String类的对象锁，故thread对象就无法在其自己线程内再打开run方法中的互斥锁，因此无法执行run方法，而main方法又因thread.join();语句尚未执行停滞再了thread.join();语句处，从而导致了死锁 ==》可以看到 join() 方法并不能释放String类的对象锁，故导致main线程与子线程之间发生死锁，只能手动停止程序

    • 情景二：直接对子线程对象上锁，锁为子线程的对象锁
    //测试插队线程
public class TestJoin implements Runnable{
    String hello;
 
    public TestJoin(String hello) {
        this.hello = hello;
    }
 
    @Override
    public void run() {
        synchronized (this){
            for (int i = 0; i < 5; i++) {
                System.out.println("插队线程执行" + hello);
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        String hello = "hello";
 
        //启动插队线程
        Thread thread = new Thread(new TestJoin(hello));
        thread.start();
 
        synchronized (thread){
            //主线程
            for (int i = 0; i < 10; i++) {
                if (i==5){
                    thread.join();
                }
                System.out.println("主线程执行" + hello);
            }
        }
 
    }
}

    • 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

    说明：这里我们用thread线程类对象（即要调用 join() 方法的对象）来充当两个同步代码块的对象锁，由于调用 join() 方法可以释放被调用线程的对象锁（即将被调用线程的对象作为对象锁），因此此时在主线程的锁就被释放，且被thread线程类对象抢占，这样thread对象就可以顺利执行 thread.join(); 这条语句完成插队并在插队线程完成执行后释放锁并回到main方法的同步代码块，此时main线程再次占有锁并继续执行完方法

    扩展思考：若thread线程类对象先抢到锁会如何？
    ① 若thread线程类对象在抢到锁后且一直占有锁并执行完了run方法，那么该线程就会死亡。这时再执行到main线程内的thread.join()也不会发生死锁了，因为join方法不是去执行的，而是“It waits for the thread to die”等待线程死亡，既然现在线程已经死亡，也就不用等待，main线程继续正常执行即可。
    ② 若thread线程类对象在抢到锁后并未执行完run方法就被main线程抢到了锁，那么此时可能与情景二的过程一样，也有可能main线程的for循环未执行满5次又被thread线程类对象抢到锁后出现 ① 的情况，或也有可能交替执行，但无论如何最后都会到情景二或①这两种结果。具体还是要看底层内核态操作系统是怎么分配CPU资源的，是咋们程序员控制不了的。

    线程练习

    1.题一
    在这里插入图片描述

    package com.hspedu.homework;

import java.util.Scanner;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);//一定要注意.
        a.start();
        b.start();
    }
}

//创建A线程类
class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        //输出1-100数字
        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("a线程退出...");

    }

    public void setLoop(boolean loop) {//可以修改loop变量
        this.loop = loop;
    }
}

//直到第2个线程从键盘读取了“Q”命令
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) {//构造器中，直接传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            //接收到用户的输入
            System.out.println("请输入你指令(Q)表示退出:");
            char key = scanner.next().toUpperCase().charAt(0);
            if(key == 'Q') {
                //以通知的方式结束a线程
                a.setLoop(false);
                System.out.println("b线程退出.");
                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
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    在这里插入图片描述

    知识点：使用通知方式来终止线程

    2.题二
    在这里插入图片描述

    package com.hspedu.homework;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        thread1.setName("t1");
        Thread thread2 = new Thread(t);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
}

//编程取款的线程
//1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
//2. 每次取出 1000
class T implements  Runnable {
    private int money = 10000;

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

            //解读
            //1. 这里使用 synchronized 实现了线程同步
            //2. 当多个线程执行到这里时，就会去争夺 this对象锁
            //3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
            //4. 争夺不到this对象锁，就blocked ，准备继续争夺
            //5. this对象锁是非公平锁.

            synchronized (this) {//
                //判断余额是否够
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }

                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " 取出了1000 当前余额=" + money);
            }

            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


    • 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
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    在这里插入图片描述

    知识点：同步机制，使用关键字 synchronized 加上互斥锁从而实现线程同步

  • 相关阅读:
    基于Kubernetes/K8S构建Jenkins持续集成平台（一）
    gdb远程使用
    释放搜索潜力：基于ES(ElasticSearch)打造高效的语义搜索系统，让信息尽在掌握[2.项目讲解篇],支持Linux/Windows部署安装
    【循环自相关和循环谱系列7】OFDM循环自相关推导分析、时间参数估计原理仿真及某无人机实际图传信号验证(含矩形/非矩形、有无循环前缀等情况)
    js如何设置私有属性
    Java 并行 GC 调优
    使用Chatgpt编写的PHP数据库pdo操作类（增删改查）
    中国领先世界的机会稍纵即逝
    Prometheus+Grafana对Mysql实现监控
    《动手学深度学习 Pytorch版》 4.10 实战Kaggle比赛：预测比赛
  • 原文地址：https://blog.csdn.net/weixin_53063457/article/details/132996778