17Java多线程

最新推荐文章于 2024-02-04 10:54:28 发布
最新推荐文章于 2024-02-04 10:54:28 发布
阅读量148 收藏
点赞数
分类专栏： JAVA基础 文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingxiao123/article/details/130270378
版权
本文详细介绍了Java中的线程概念，包括进程与线程的区别，线程的并发与并行，以及如何通过继承Thread类和实现Runnable接口创建线程。文章还讨论了线程的生命周期、同步机制，如synchronized关键字的使用，以及线程死锁的概念和案例分析。
摘要由CSDN通过智能技术生成

17多线程

1. 线程及其相关概念

  • 程序：是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码

  • 进程：

    1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
    2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程

  • 线程：

    1. 线程由进程创建的，是进程的一个实体

    2. 一个进程可以拥有多个线程，如下图：

    在这里插入图片描述

    整个迅雷看作一个进程，里面的每一个下载任务看成一个线程

  • 其他概念：

在这里插入图片描述

在这里插入图片描述

并发：某一时刻点上只执行一个任务，不同时刻来回切换执行。并行：某一时刻点上可以同时进行多个任务。

并发和并行可能同时都存在。

public class CpuNum {
    public static void main(String[] args) {
        //Runtime.getRuntime();  说明是一个单例模式，通过getRuntime()来获取一个实例对象
        Runtime runtime = Runtime.getRuntime();
        //获取当前电脑的cpu数量/核心数
        int cpuNums = runtime.availableProcessors();
        System.out.println("当前cpu数量: " + cpuNums);
    }
}

2. 线程的使用

2.1 创建线程

在这里插入图片描述

2.2 继承 Thread 类案例

在这里插入图片描述

演示主线程结束了，子线程不一定结束：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个Cat对象，可以当作一个线程使用了
        Cat cat = new Cat();
        cat.start();//启动子线程

        //说明当main线程启动一个子线程 Thread-0后，主线程（即main）不会阻塞，会继续执行
        //这时，主线程和子线程是交替执行...
        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，这时线程也就退出了..
            }
        }
    }
}

在这里插入图片描述

在这里插入图片描述

9664 相当于是线程号

在这里插入图片描述

2.3 start() 方法

//继续上面的代码分析
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个Cat对象，可以当作一个线程使用了
        Cat cat = new Cat();
        cat.start();//start()方法启动子线程 -> 执行Cat的run()方法
        /*  start()源码分析：
            (1)
            public synchronized void start(){
                start0();
            }
            (2)
            //start(0)  是本地（native）方法，是JVM调用，底层是c/c++实现
            //真正实现多线程效果的是 start0()方法，而不是run()方法
            private native void start0();
         */

        //如果不用上面而用下面这一条语句执行run方法，就相当于主线程main执行一个普通方法，
        // 没有真正启动一个线程，就会把run方法执行完毕，才会继续执行下面的代码
        //cat.run();

        //说明当main线程启动一个子线程 Thread-0后，主线程（即main）不会阻塞，会继续执行
        //这时，主线程和子线程是交替执行...
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//主线程名字就叫main
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i= " + i);
            //让主线程休眠
            Thread.sleep(1000);//抛出异常
        }
    }
}

在这里插入图片描述

2.4 实现 Runnable 接口案例

在这里插入图片描述

在这里插入图片描述

//实现Runnalbe接口来开发 多线程案例 

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();
    }
}

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;
            }
        }
    }
}

//模拟代理模式，
public class Thread02 {
    public static void main(String[] args) {
		Tiger tiger = new Tiger();
        ThreadPoxy poxy = new ThreadPoxy(tiger);
        poxy.start();
        /*分析
        首先分析： new ThreadPoxy(tiger)
        因为ThreadPoxy的构造器为：public ThreadPoxy(Runnable target)，可以接受一个实现了Runnable接口的对象，而Tiger类		刚好实现了Runnable接口 ，因此Tiger类的对象tiger可以传入，此时ThreadPoxypoxy类（模拟Thread类）的对象poxy的属性		 private Runnable target = tiger。
        
        分析poxy.start();
        1.poxy.start()执行，然后调用start0()方法，与真实的Thread一样（通过start()方法调用start0()方法）
        2.在start0()方法中调用run()方法，此时是调用ThreadPoxypoxy类的run()方法，进行判断 if (target != null)，因为	target = tiger不为null，进入if，执行target.run() 方法，根据动态绑定，调用tiger的run()，输出："老虎嗷嗷叫..."
        
        总结：一定要通过start()方法调用了start0()方法，才能创建一个线程。而start0()方法会通过某种方式执行run()方法
        */
    }
}

class Animal{}
//由于java的单继承模式，这里Tiger已经继承了Animal类了，就不能通过继承Thread类来实现多线程了，只能通过实现Runnable接口实现
class  Tiger extends Animal implements Runnable{
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫...");
    }
}

//线程代理类（模拟线程代理），这里的ThreadPoxy类模拟了一个极简的Thread类
class ThreadPoxy implements Runnable{
    
    private Runnable target = null;

    @Override
    public void run() {
        if (target != null){
            target.run();
        }
    }

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

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

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

2.5 多线程案例

在这里插入图片描述

/**
 * 在main线程启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread.start();//启动线程1
        thread1.start();//启动线程2
    }
}

class T1 implements Runnable{
    private int count = 0;

    @Override
    public void run() {
        while (true) {
            //每隔一秒钟输出 hello word，输出10次
            System.out.println("hello word " + ++count);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10){
                break;
            }
        }
    }
}

class T2 implements Runnable{
    private int count = 0;

    @Override
    public void run() {
        while(true) {
            //每隔一秒钟输出 hi，输出5次
            System.out.println("hi " + ++count);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5){
                break;
            }
        }
    }
}

在这里插入图片描述

上图解释：横向箭头表示创建，纵向箭头表示执行，蓝色矩形长度表示执行时间长短。注意：有可能 main 线程 结束了，子线程还在执行。

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

在这里插入图片描述

//对上面第二条的解释
T3 t3 = new T3("hello");
Thread thread1 = new Thread(t3);
Thread thread2 = new Thread(t3);
thread1.start();
thread2.start();
//线程thread1，thread2共享t3

在这里插入图片描述

/**
 * 使用多线程的两种方式，模拟三个窗口同时售票（一共100张）
 */
public class Thread04 {
    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();

        //使用实现Runnable接口方式测试
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread thread1 = new Thread(sellTicket02);
        Thread thread2 = new Thread(sellTicket02);
        Thread thread3 = new Thread(sellTicket02);
        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

//使用继承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));
        }
    }
}

//实现Runnable接口的方式
class SellTicket02 implements Runnable{
    private int ticketNum = 100;//这里不用static

    @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));
        }
    }
}
/*
输出如下图
解释超卖：假如ticketNum还有2张，当线程1来访问时，先判断if(ticketNum <= 0)，不执行if，然后执行休眠50毫秒的代码，在这期间，线程2和3可能也会进来访问，当线程1还没有执行--ticketNum的时候，还是有票，if(ticketNum <= 0)判断还是不执行if，所以这个时候就进来了3个线程同时访问ticketNum，导致最后出现超卖现象，且为-1；同理，假如ticketNum还有1张，上述情况再次发生，那么最后也会出现超卖，且为-2
*/

在这里插入图片描述

4. 线程终止

在这里插入图片描述

在这里插入图片描述

public class Thread05 {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

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

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

class T extends Thread{
    int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop){
            //每隔50ms输出
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T线程 运行中..." + (++count));
        }
    }

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

5. 线程的常用方法

5.1 第一组方法

  • 第一组方法：

在这里插入图片描述

  • 注意事项：

在这里插入图片描述

//上面2的三个优先级
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
  • 具体例子：
public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("老韩");//
        t.setPriority(Thread.MIN_PRIORITY);
        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());
        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(10000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常，不是终止
                System.out.println(Thread.currentThread().getName() + "被 interrupt 了");
            }
        }
    }
}

5.2 第二组方法

  • 第二组方法：

在这里插入图片描述

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

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

                //yield，线程礼让，不一定成功
                Thread.yield();
                System.out.println("子线程（老大）吃完了，主线程（小弟）接着吃...");
            }
        }
    }
}

class T2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程（老大） 吃了 " + i + " 包子");
        }
    }
}

5.3 课堂练习

在这里插入图片描述

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        Thread thread = new Thread(t);

        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            Thread.sleep(1000);
            if(i==5){//说明主线程输出了5次 hi
                thread.start();//启动子线程，输出hello...
                thread.join();//立即将子线程thread，插入到main，让thread先执行

            }
        }
    }
}

class T implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; ) {
            System.out.println("hello " + ++i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程结束了...");
    }
}

5.4 用户线程和守护线程

在这里插入图片描述

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当主线程结束后，子线程可以自动结束。只需要把子线程设置为守护线程即可。
        myDaemonThread.setDaemon(true);//此句要在start()之前
        myDaemonThread.start();
        
        for (int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

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

6. 线程的生命周期

6.1 线程的状态

在这里插入图片描述

在这里插入图片描述

注意Runnable状态可以分为Ready状态和Running状态，这取决于线程是否被调度器选中执行。

6.2 查看状态例子

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        //才new好一个线程，并没有执行，状态为NEW
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()){
            //线程调用start()方法后，就会变为RUNNABLE状态（根据是否被调度器执行又分为READY和RUNNING）
            //调用sleep()方法的时候就会出现超时等待状态 TIMED_WAITING
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }
        //退出线程后就会出现TERMINATED状态
        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;
        }
    }
}

7. 线程同步

7.1 线程同步机制

在第3节，售票问题中出现了超卖的问题，这是因为线程没有同步

在这里插入图片描述

在这里插入图片描述

//售票问题超卖问题通过synchronized来解决
public class Thread04 {
    public static void main(String[] args) {
        //使用实现Runnable接口方式测试
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread thread1 = new Thread(sellTicket02);
        Thread thread2 = new Thread(sellTicket02);
        Thread thread3 = new Thread(sellTicket02);
        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

//实现Runnable接口的方式，使用synchronized实现线程同步
class SellTicket02 implements Runnable{
    private int ticketNum = 100;//这里不用static
    private boolean loop = true;

    public synchronized void m(){//同步方法，在同一个时刻，只能有一个线程来执行m()方法
        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));
    }

    @Override
    public void run() {
        while (loop){
            m();
        }
    }
}

//注意：如果是吧synchronized关键字来修饰run()方法，那么当第一个线程thread1.start();先进来访问run()的时候，其他方法就没法进来访问run()，所以就一直都是一个线程在卖票。因为这三个线程共享同一个sellTicket02，使用的都是它的run()方法。

7.2 同步原理与互斥锁

在这里插入图片描述

分析：假如一个方法被定义成 synchronized 如上，那么当 t1、t2 和 t3 三个线程来访问时，它们三个会去“抢”这个“锁”，谁抢到了，谁就进入方法执行。假如线程 t1 抢到了“锁”，那么它进入方法执行，输出后返回，并把 锁放回去，放回去之后 t1、t2 和 t3 三个线程又来抢“锁”，依旧谁抢到谁执行方法。注意 t1 可以再次抢“锁”

  1. Java 语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应于一个可称为 “互斥锁” 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  3. 关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法（非静态的）的锁可以是 this（即锁是加在当前对象上的），也可以是其他对象（要求是同一个对象）
  6. 同步方法（静态的）的锁为当前类本身（即锁是加在当前类上的）。

备注：上面第5条不是很懂

//再谈 售票问题
public class Thread04 {
    public static void main(String[] args) {
        //使用实现Runnable接口方式测试
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread thread1 = new Thread(sellTicket02);
        Thread thread2 = new Thread(sellTicket02);
        Thread thread3 = new Thread(sellTicket02);
        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

//实现Runnable接口的方式，使用synchronized实现线程同步
class SellTicket02 implements Runnable{
    private int ticketNum = 100;//这里不用static
    private boolean loop = true;
    //解释：同步方法（非静态的）的锁可以是 this（即锁是加在当前对象上的），也可以是其他对象（要求是同一个对象）
    Object object = new Object();
    
    @Override
    public void run() {
        while (loop){
            m();
        }
    }

    //1.public synchronized void m()就是一个同步方法
    //2.这时，锁在this对象上
    //3.也可以在代码块上写 synchronized ，同步代码块（注释该方法，重写如下一个）
//    public synchronized void m(){//同步方法，在同一个时刻，只能有一个线程来执行m()方法
//        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));
//    }

    //在代码块上写 synchronized ，同步代码块，互斥锁还是在this对象
    public void m(){
        synchronized (/*this*/object){//object解释上面第5条
        //对上面的synchronized (object)的解释：在main方法中只创建了1个SellTicket02的对象sellTicket02，
        //但是创建了三个线程，每个线程都共享这个对象sellTicket02。如果是synchronized (this)，那么锁是加在sellTicket02上
        //如果是synchronized (object)，因为对象object是对象sellTicket02的一个属性，这个object对象也就被三个线程共享了
       //因此synchronized (object)把锁加在object上，三个线程进来后抢的仍然是加在同一个对象上的锁（访问的是同一个object），
        //即抢加在他们共享的object上的锁，所以效果跟synchronized (this)一样。
        //如果把synchronized (object)改为synchronized (new 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));
        }
    }
    

    //第6条：同步方法（静态的）的锁为当前类本身
    //1.public synchronized static void m1(){} 锁是加在 SellTicket02.class 这个类上的
    public synchronized static void m1(){

    }
    //2.如果在静态方法中，实现一个同步代码块，处理如下：synchronized (SellTicket02.class)，即把锁加在类本身 上
    public static void m2(){
        synchronized (/*this*/SellTicket02.class){//这里synchronized (this)是不可以的，静态方法里面不能直接使用this
            System.out.println("m2");
        }
    }
}

使用细节：

在这里插入图片描述

注意：第3条是优先选择同步代码块。上面第3条最后一句解释如下：

class SellTicket01 extends Thread{
    
    public void m1(){
        synchronized (this){
            System.out.println("hello");
        }
    }
    
}
/*
如果是以上述继承 Thread 类的方式来实现线程，并且使用同步代码块synchronized (this)，这个时候括号里为this就不行。因为继承Thread实现线程的方式为：
SellTicket01 sellTicket01 = new SellTicket01();  SellTicket01 sellTicket02 = new SellTicket01();
sellTicket01.start();  sellTicket02.start();
每次开启一个新线程都要重新创建 一个对象，然后调用对象的statr()方法开启线程，这时候每个线程的this都是本对象即sellTicket01、sellTicket02，所以锁不是加在同一个对象上，根本锁不住（两个线程抢的不是同一把锁）
因此，得出继承Thread的方式要锁类
*/

8. 线程的死锁

8.1 基本介绍

在这里插入图片描述

在这里插入图片描述

8.2 案例说明

//模拟死锁
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状态
        //5.这样就会出现死锁
        if (flag){
            synchronized (o1){//这里通过synchronized加了一个对象(o1)互斥锁，因此下面就是同步代码。线程必须拿到这个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");
                }
            }
        }
    }
}
//输出如下：

在这里插入图片描述

8.3 释放锁

释放锁的操作如下：
在这里插入图片描述

不会释放锁的操作如下：

在这里插入图片描述

结合下图分析：

可以看到执行 Thread.yeild() 方法时，可能会从 Running 状态转化到 Ready 状态，但是他们都是 Runnable 状态，并没有释放锁（被挂起同理）。而执行了 Thread.sleep() 方法后，会从 Runnable 状态装换为 TimedWaiting 状态，这个时候并不会释放锁，并且时间结束后会再次进入 Runnable 状态，所以阻塞在Blocked 状态的线程不能获得锁。

在这里插入图片描述

野猪杀手X
关注
专栏目录
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
yinying293的博客
01-26 904
Java多线程：线程创建、线程状态、线程安全、死锁、线程池、Lock接口、线程安全集合
Java线程进程
weixin_44207220的博客
10-18 314
进程线程
JAVA-17 多线程
m0_59214979的博客
11-21 634
本节：多线程就是几条线路同时执行。 单线程就是按照顺序，只有一条线路执行，执行完一个方法，再执行其他方法。 多线程的写法：使用Thread的多态写法，再new Runable(),在里面调用方法就可以了 ​​​​​​ ...
Java23多线程4：总结和练习
Bruce的博客
04-04 377
多线程总结和常见问题
Java-基础篇-17-【线程-同步】
Alan0517
03-07 457
【线程、同步】
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
Java多线程知识点总结
08-19
Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...
Java——多线程使用详解
itzhuzhu的博客
10-01 951
目录： 并发与并行 线程与进程 创建线程 start和run的区别 获取和修改线程的名称 获取当前线程 线程睡眠 实现接口创建线程 匿名内部类创建线程 1.并发与并行： 并行: 两个或以上的事件在同一时刻发生(同时发生) 举例:比如12:30:30,一个小朋友一边吃饭,一边打电话 并发: 两个或以上的事件在一个时间段内发生(交替执行) 举例:比如12:30~12:35这个时间段内一个...
Java7 多线程
God_Of_Gun的博客
09-28 288
多线程 Java.Thread 目录 线程简介 线程实现（重点） 线程状态 线程同步（重点） 线程通信问题 高级主题 线程简介 任务、进程、线程、多线程 一个进程可以有多个线程，如视频中同时听声音、看视频、看弹幕等 Process与Thread 程序s是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 进程则是执行程序的一次执行过程，是一个动态的概念。是系统组员分配的单位 一个进程包含了若干个线程。一个进程至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位。 注意：很多
Java— 齐头并进完成任务—多线程
LiLi的博客
08-07 1197
感知多线程 Java是少数的几种支持“多线程”的语言之一。大多数的程序语言只能循序运行单独的一个程序块，无法同时运行不同的多个程序块。Java的“多线程”恰可弥补这个缺憾，它可以让不同的程序块并发执行，如此一来就可让程序运行得更为顺畅，同时也可达到多任务处理的目的。 现实生活中的多线程 任何抽象的理论（本质）都离不开具体的现象。通过现象比较容易看清楚本质，在没有讲解Java的多线程概念之前，我们先从现实生活中体会一下“多线程”。 在高速公路收费匝道上，经常会看到排成长龙的车队。如果让你来缓解这一拥塞的交通状
Java多线程17：中断机制
weixin_34376562的博客
10-05 219
概述 之前讲解Thread类中方法的时候，interrupt()、interrupted()、isInterrupted()三个方法没有讲得很清楚，只是提了一下。现在把这三个方法同一放到这里来讲，因为这三个方法都涉及到多线程的一个知识点----中断机制。 Java没有提供一种安全、直接的方法来停止某个线程，而是提供了中断机制。中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而...
JDK1.7中的ThreadPoolExecutor源码剖析
RipL的专栏
08-10 4515
JDK1. 7中的ThreadPoolExecutor线程池，顾名思义一个线程的池子，池子里存放了很多可以复用的线程，如果不用线程池类似的容器，每当我们需要创建新的线程时都需要去new Thread（），用完之后就被回收了，线程的启动回收都需要用户态到内核态的交互，频繁的创建开销比较大。而且随着线程数的增加，会引起CPU频繁的上下文切换严重影响性能。这时候线程池类似的容器就发挥出了作用。线程池里面的
JDK17 动态设置线程池核心线程数以及最大线程数
最新发布
wl1411956542的博客
02-04 548
在以前使用jdk8的时候，曾经使用过动态线程池，也就是在线程池运行过程中，动态修改其核心程池数以及最大线程数，以控制对三方接口的并发调用。但是在我们将jdk8切换至jdk17之后，调用这两个方法的地方开始报 IllegalArgumentException。可以看到jdk17在进行核心线程数修改以及最大线程数修改时，增加了新的判断，要求，设置这两个参数时都必须保证最大线程数 大于等于 核心线程数。
java学习笔记 - 第17章：多线程基础
qq_48457459的博客
04-27 1114
线程相关概念(单线程多线程,并发并行),创建线程的两种方式及代码演示，多线程机制及如何理解，JConsole监控线程，为什么用start()，代码演示：代理模式，继承Thread vs 实现Runnable接口，多线程售票出现的问题及解决方式，通知线程退出，线程常用方法，线程中断，线程插队，守护线程，线程的生命周期，同步机制的使用及代码实例，互斥锁，死锁，释放锁，取钱案例
Java-多线程
Honson的博客
05-18 263
一 、线程相关知识 1、概述 首先我们来认识一下什么是程序、进程； 程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码； 进程(process)：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域； 线程 线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小； Java程序
java协程线程之虚拟线程
Gefangenes的博客
08-04 431
平台线程我就不过多描述因为大家都知道，网上的描述也特别多；虚拟线程，其实我们更多可以可以考虑他只是一个任务，异步的任务；区别在于，平台线程受制于cpu，如果你执行任务很耗时或者比如网络io等挂起等待，那么这个cpu也会一直挂起等待无法处理其他事情；虚拟线程是异步任务凌驾于平台线程之上，也就是说，当你的虚拟线程等待挂起的时候，平台线程就去执行其他任务（其他虚拟线程）去了我们通过上面测试用例可以这样理解，
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值