多线程（线程池、死锁、线程状态、等待与唤醒）

最新推荐文章于 2024-01-05 13:00:00 发布
最新推荐文章于 2024-01-05 13:00:00 发布
阅读量212 收藏
点赞数
分类专栏： 学习篇 Java 多线程 文章标签： 多线程 java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45144691/article/details/107640604
版权
学习篇 同时被 3 个专栏收录
24 篇文章 0 订阅
订阅专栏
Java
17 篇文章 0 订阅
订阅专栏
多线程
2 篇文章 0 订阅
订阅专栏

多线程基础

线程池

概念及作用

  1. 什么是“线程池”：它是一个“容器”，里面可以存储一些“线程对象”。
  2. 它的作用：
    1. 它可以“反复的”执行同一个线程对象，可以避免每次使用这个线程对象，而去创建这个线程对象。
    2. 它内部可以控制多个线程的“并发数量”；

线程池的类层次结构

  1. java.util.concurrent.Executor(接口)：所有线程池的父接口
    |–java.util.concurrent.ExecutorService(接口)：我们学习使用的“线程池”：
  2. 常用方法：
    1. submit(Runnable run)：用于执行Runnable线程
    2. submit(Callable cal):用于执行Callable线程。
  3. 可以通过一个“Executors工具类”来获取ExecutorService的子类对象：
    java.util.concurrent.Executors(工具类)的静态方法；
    public static ExecutorService newFixedThreadPool(int nThreads)
代码演示：
package com.itheima.demo01_线程池的使用;

public class MyThread extends Thread {
    public MyThread(){
        System.out.println("构造线程对象很耗时，需要5秒...");
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("鼓掌" + i);

        }
    }
}

package com.itheima.demo01_线程池的使用;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo01 {
    public static void main(String[] args) {
        /*MyThread t1 = new MyThread();//需要5秒
        t1.start();
        MyThread t2 = new MyThread();//需要5秒
        t2.start();*/
        //改用线程池
        //1.获取线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);
        //2.创建自定义线程对象
        MyThread t  = new MyThread();//需要5秒
        //3.使用"线程池"去执行t线程
        service.submit(t);//开始执行

        //可以让线程池反复的执行同一个t线程
        service.submit(t);//开始执行

        service.submit(t);//由于核心线程只有2，所以前两个线程会"同时执行"，第三个线程会排队

        //结束线程池
        service.shutdown();//会等待所有的线程执行完毕，然后再关闭。


    }
}
代码图解

在这里插入图片描述

实现线程的第三种方式：可以通过返回值的Callable接口

  1. 之前我们实现线程的两种方式：
    1. 继承Thread类，重写run()方法。
    2. 实现Runnable接口，重写run()方法。
  2. 之前的两种方式都有两个弊端：
    1. 子类重写run()方法时，不能抛出“编译期异常”；
    2. run()方法没有返回值，不能给它的启动线程返回一个值；
  3. 从JDK1.5开始，Java提供了第三种实现线程的方式：
    1. 自定义类，实现Callable接口，并重写call()方法。
    2. 启动线程(注意：启动Callable线程，必须要用线程池)
      1. 获取一个线程池对象：
      2. 使用线程池启动Callable线程，并通过Future对象获取线程的返回值；
代码演示
package com.itheima.demo02_实现线程的第三种方式_可以返回值的Callable接口;

import java.util.concurrent.Callable;

//要求：此线程要计算1--100的累加和，并返回给调用线程
public class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            sum += i;
            Thread.sleep(50);
        }
        System.out.println("【线程】计算完毕！");
        return sum;
    }
}

package com.itheima.demo02_实现线程的第三种方式_可以返回值的Callable接口;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo02 {
    public static void main(String[] args) {
        //1.获取线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);
        //2.创建自定义线程对象
        MyThread t = new MyThread();

        //3.使用线程池去执行我们的线程
        Future<Integer> future = service.submit(t);//不阻塞，启动线程
        while (!future.isDone()){//判断线程是否结束，如果没结束，就可以做点其他事情，可以避免提前调用get()而产生的阻塞。
            System.out.println("线程没执行完，可以做一些其他的事情！");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            System.out.println("获取future的结果：");
            Integer result = future.get();//阻塞的，等待计算完成
            System.out.println("线程执行结果：" + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //关闭线程池
        service.shutdown();

    }
}
代码图解

在这里插入图片描述

线程状态

线程状态概述

  1. 一个线程，从创建对象开始，到最后被销毁，中间由于调用线程的各种方法，会使线程进入不同的“状态”。

  2. 一个线程可能的几种状态：
    在这里插入图片描述
    在这里插入图片描述

等待和唤醒

  1. 等待和唤醒机制：它是“两个线程”之间相互协作的一种机制。一个线程先开始工作，当发现一些问题时，可以主动“退出—释放锁”，让另一个线程开始执行，第二个线程拿到锁后，就可以开始工作—解决问题，解决完问题后，再“唤醒-让之前等待的线程，从’无限等待’状态进入到’可运行状态’去抢锁”。这样就实现了：两个线程相互协作，共同完成一项任务。
  2. 实现前提：
    1. 要有两个线程；
    2. 两个线程要共用一把锁；
  3. 注意：
    1. wait()和notify()、notifyAll()都是Object的方法，因为“任何对象都可以做锁”，所以任何对象都可以“进入等待”。
    2. wait(long s)和sleep(long s)的区别：
      1. wait(long s)可以被唤醒；
        sleep(long s)必须时间到，然后自己醒；
      2. wait()方法会释放锁；
        sleep()方法不会释放锁。
代码演示
	public class Demo04 {
    public static void main(String[] args) throws InterruptedException {
        //1.定义一把锁
        Object obj = new Object();
        //2.定义两个线程
        //第一个线程：主工作线程
        new Thread(){
            //必须要先启动，先拿到锁
            @Override
            public void run() {
                synchronized (obj) {
                    for (int i = 0; i < 50; i++) {
                        System.out.println("白雪公主线程：i = " + i);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (i == 20) {
                            System.out.println("白雪公主线程 i = 20，主动退出，释放锁，进入到'无限等待状态'，等待白马王子...");
                            try {
                                obj.wait();//无限等待，等待被其他线程唤醒
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }.start();
        Thread.sleep(1000);//为了保证让"白雪公主"线程先运行

        //白马王子线程
        new Thread(){
            @Override
            public void run() {
                System.out.println("【白马王子】线程启动，获取锁......");
                synchronized (obj){
                    System.out.println("【白马王子】拿到锁，终于可以娶白雪公主了！！！");
                    System.out.println("【白马王子】和白雪公主举行婚礼！");
                    try {
                        Thread.sleep(1000 * 5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("【白马王子】婚礼举行完毕，和白雪公主愉快的度过余生！");
                    //唤醒白雪公主线程，继续生活
                    obj.notifyAll();//【特别注意】唤醒，不释放锁-会让在这个锁上等待的线程，由'无限等待状态'转入到'可运行状态'，去抢锁。
                }//执行完同步代码块，才释放锁
            }
        }.start();
    }
}
包子铺案例
  1. 包子铺案例：这个案例需要两个线程：一个线程无限“生产包子”，一个线程无限“获取包子”，我们会有一个集合，来存放包子。
  2. 我们的程序必须要控制：生产一个，卖出一个。不会生产多个！生产一个，来买包子的，也必须要买走一个。
    在这里插入图片描述
代码演示
  1. 生产者线程：

public class SetThread extends Thread {
    @Override
    public void run() {
        int index = 1;
        while (true) {
            synchronized (Demo05.bzList){
                if (Demo05.bzList.size() > 0) {//有包子
                    try {
                        System.out.println("【生产者】有包子，等待消费者...");
                        Demo05.bzList.wait();
                        System.out.println("【生产者】被唤醒...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果没有包子，或者被唤醒
                //生产一个包子
                String s = "包子" + index++;
                Demo05.bzList.add(s);
                System.out.println("【生产者】生产：" + s);
                //唤醒消费者线程
                Demo05.bzList.notify();
            }
        }
    }
}
  1. 消费者线程
public class GetThread extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Demo05.bzList) {
                if (Demo05.bzList.size() == 0) {//没有包子
                    try {
                        Demo05.bzList.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果有包子，或者被唤醒
                //取走一个包子
                String s = Demo05.bzList.remove(0);
                System.out.println("【消费者】拿走：" + s);
                //唤醒生产者线程
                Demo05.bzList.notify();
            }
        }
    }
}
  1. 测试类
public class Demo05 {
    public static ArrayList<String> bzList = new ArrayList<>();

    public static void main(String[] args) {
        //1.启动两个线程
        new SetThread().start();
        new GetThread().start();
    }
}

定时器Timer的使用

  1. 创建一个Timer对象
    Timer t = new Timer();
  2. 设置时间、任务，并会启动任务。
    1. public void schedule(TimerTask task, long delay) 在指定的延迟之后安排指定的任务执行。一次性定时器
    2. public void schedule(TimerTask task, long delay,long period)在指定的delay延迟之后开始task任务，然后会每隔period时间，会反复执行task任务。往复定时器。
    3. public void schedule(TimerTask task, Date time) 在指定的时间安排指定的任务执行。
    4. public void schedule(TimerTask task, Date firstTime, long period)从指定的时间开始，对指定的任务执行重复的 固定延迟执行 。
代码演示
	public class Demo06 {
    public static void main(String[] args) throws ParseException {
        //1.public void schedule(TimerTask task, long delay)：一次性
        /*Timer t1 = new Timer();
        t1.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("嘣......");
                t1.cancel();//结束"定时器"
            }
        },1000 * 2);

        System.out.println("t1已启动，2秒后开始！");*/

        //2.public void schedule(TimerTask task, long delay,long period)：往复定时器
       /* Timer t2 = new Timer();
        t2.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("嘣......");
            }
        },1000 * 2,1000);*/

       //3).public void schedule(TimerTask task, Date time) 在指定的时间安排指定的任务执行。
        /*Timer t3 = new Timer();
        String str = "2020-07-28 14:35:00";
        t3.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("扫描全盘......");
                t3.cancel();
            }
        },new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str));

        */

        //4).public void schedule(TimerTask task, Date firstTime, long period)从指定的时间开始，对指定的任务执行重复
        //的 固定延迟执行 。
        Timer t4 = new Timer();
        String str = "2020-07-28 14:37:15";
        t4.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("扫描全盘...");
            }
        },new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str),1000);
    }
}

死锁

  1. 当两个线程，交替使用“两把锁”的时候，就可能产生“死锁”的情况，我们编程时，应该避免这种情况。
  2. 如果项目需要两个线程交替使用两把锁，应该有一些预案，来防止死锁。
代码演示
package com.itheima.demo03_死锁的现象演示;
public class ThreadA extends Thread {
    @Override
    public void run() {
        System.out.println("【线程A】去拿锁1...");
        synchronized (Demo03.obj1) {
            System.out.println("【线程A】拿到锁1，去拿锁2...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Demo03.obj2) {
                System.out.println("【线程A】拿到锁2...");
            }
        }
    }
}

package com.itheima.demo03_死锁的现象演示;
public class ThreadB extends Thread {
    @Override
    public void run() {
        System.out.println("【线程B】去拿锁2...");
        synchronized (Demo03.obj2) {
            System.out.println("【线程B】拿到锁2，去拿锁1...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Demo03.obj1) {
                System.out.println("【线程B】拿到锁1...");
            }
        }
    }
}

package com.itheima.demo03_死锁的现象演示;

public class Demo03 {
    public static Object obj1 = new Object();//锁1
    public static Object obj2 = new Object();//锁2
    public static void main(String[] args) {
        //1.启动两个线程
        new ThreadA().start();
        new ThreadB().start();
    }
}
代码图解

在这里插入图片描述

多线程基础

Li大爷_初学者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java=线程池，死锁，线程状态
人生起落，生活苦甜，坚持追求！
03-18 273
线程池 死锁 线程的状态 定时器 一。线程池 使用线程时,我们会临时创建一个线程,然后启动,而线程的创建,以及线程使用完毕之后的销毁,都是需要消耗性能的. 思考: 能不能事先把线程对象创建好,然后需要用到时直接把创建好的线程拿过来使用, 使用完毕,重新归还,等待下次继续使用??? 能! 其实这就是线程池的思想 线程池: 其实就是一个保存多个线...
线程池使用介绍用程序可以有多个线程，这些线程在休眠状态中需要耗费大量时间来等待事件发生。其他线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态
09-20
应用程序可以有多个线程，这些线程在休眠状态中需要耗费大量时间来等待事件发生。其他线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态。为了简化对这些线程的管理，.NET框架为每个进程提供了一个线程池，一个线程池有若干个等待操作状态，当一个等待操作完成时，线程池中的辅助线程会执行回调函数。线程池中的线程由系统管理，程序员不需要费力于线程管理，可以集中精力处理应用程序任务。 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙.如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值.超过最大值的线程可以排队,但他们要等到其他线程完成后才启动
java 线程 防止_Java中的线程死锁是什么？如何避免？
weixin_35569158的博客
02-16 349
认识线程死锁多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：public class DeadLockDemo {...
Java线程及线程池状态
weixin_34390105的博客
05-21 246
一、Java线程的六种状态   如上图1，JDK定义线程状态是不存在“运行中”状态，但为方便描述过程有些图中会画出运行中的状态。 Java线程创建后调用start方法进入就绪状态，被OS调度选中后运行，运行结束或程序退出或抛异常时终止。 运行中线程调用Thread.yield（）方法状态切换为可运行就绪状态；运行中线程执行时遇到IO阻塞、调用Thread.sleep或其它线程对...
五、线程同步之死锁和活锁
dengxian7675的博客
12-29 189
死锁和活锁现象死锁死锁现象死锁：两个或多个线程相互等待对方释放锁，则会出现死锁现象。java虚拟机没有检测，也没有采用措施来处理死锁情况，所以多线程编程是应该采取措施避免死锁的出现。一旦出现死锁，整个程序即不会发生任何异常，也不会给出任何提示，只是所有线程都处于堵塞状态。死锁情况如下图所示。下面代码中有两个对象作为锁，两个线程，线程1先持有A，请求B；线程2先持有B，请求A，导致两条线程...
多线程 锁 等待唤醒
chibi5194的博客
01-20 67
class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notFull = lock.newCondition(); final Condition notEmpty = lock...
JAVA多线程精讲下
06-22
多线程精讲下课程内容涵盖如下：l 线程的同步（线程安全问题）l 线程的死锁l 线程间通信l 线程组l 线程池l 多线程的第三种实现方案l 匿名内部类方式使用多线程l 定时器的使用l 多线程面试题
Java并发编程原理与实战
08-14
了解多线程所带来的安全风险.mp4 从线程的优先级看饥饿问题.mp4 从Java字节码的角度看线程安全性问题.mp4 synchronized保证线程安全的原理（理论层面）.mp4 synchronized保证线程安全的原理（jvm层面）.mp4 单例问题...
Java 并发编程原理与实战视频
02-25
第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四个阶段并推荐学习并发的资料 ...
龙果 java并发编程原理实战
01-26
第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四个阶段并推荐学习并发的资料 ...
Java多线程02（内存模型 死锁 等待唤醒机制 Lock锁 线程池）
qq_38557784的博客
03-14 556
Java 内存模型（面试） 1、什么是Java内存模型? 大家不要认为是我们之前讲解的JVM的内存模型，堆和栈、方法区这些概念它是JVM里面。 Java内存模型简称JMM，定义了一个线程对另一个线程可见。共享变量存放在主内存中，每个线程都有自己的本地内存(本地内存是主内存的一个副本)，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全问题。 解读：当线程1取得cpu的控制权，先会修改本地内存，x修改为1，然后把主内存中的共享变量修改成1；主内存再次将x的值同步给本地内
day18【死锁、线程状态、等待与唤醒、Lambda】
weixin_43525993的博客
06-27 291
今日内容 死锁 线程状态 等待与唤醒 教学目标 能够描述死锁产生的原因 能够说出线程6个状态的名称 能够理解等待唤醒案例 第一章 死锁 1. 什么是死锁 死锁：是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待的现象。 死锁在开发中，也会遇到，当线程进入到死锁状态时，程序中线程就会一直处于等待状态。 死锁的发生： 举例1： 我请柳岩吃饭（麻辣烫） 我点了一份。上了一双筷子 我：一支 柳岩：一支 我和柳岩就相当于两个线程，而麻辣烫相当于共享资源，两个人都没办法吃，都在等待看着
Java线程池的状态
wangqsse的博客
09-06 357
1、线程池也有自己的生命周期，不同于线程的新建状态，就绪状态，运行状态，阻塞状态，死亡状态等状态，线程池有5种状态：Running,SHUTDOWN,STOP,TIDYING,TERMINATED。 线程池状态定义代码如下： private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private s...
Java线程池状态
a308495564s的博客
07-25 895
java线程池状态主要包含五种，RUNNING、STOP、SHUTDOWN、TIDYING、TERMINATED，各种状态转换如下 一、RUNNING 线程池一旦被创建，就处于RUNNING状态 RUNNING状态可以处理当前任务，以及接收新的任务 二、STOP RUNNING状态的线程池，调用shutdownNow()方法，状态将变成STOP STOP状态不接收新任务，不处理工作队列的任务，并且会中断正在处理的任务 三、SHUTDOWN RUNNING状态的线程池，调用s...
线程停止_JAVA学习49
weixin_45863084的博客
09-17 123
线程的停止 创建线程：new Thread,线程一旦创建就进入了新生状态。 就绪状态：当调用start()方法的时候线程就进入了就绪状态，但并不意味着立即调度执行。 运行状态：进入运行状态，线程才真正的执行线程体的代码块。 阻塞状态：当调用sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度。 死亡状态：线程一旦进入死亡状态，就不能再次启动。 public class TestStop01 implements Runnable{
Java 线程池都有哪些状态？
最新发布
sanmansan的博客
01-05 700
Java 线程池都有哪些状态？
线程唤醒机制
qq_45491681的博客
04-11 135
Object类中提供了三个方法 wait()等待 notify() 唤醒单个线程 notifyAll() 唤醒所有线程 public class Student { String name; int age; boolean flag; } public class SetThread implements Runnable { private Stude...
【＜线程锁死＞】
徐明晓的博客
08-05 233
【<线程锁死>】[1] 什么是线程锁死[2] 线程锁死分为哪两种[3] 活锁[3] 线程饥饿[5] 线程活性故障总结 [1] 什么是线程锁死 线程锁死是另一种常见的线程活性故障，与线程死锁不可以混为一谈。线程锁死的定义如下： 线程锁死是指等待线程由于唤醒其所需的条件永远无法成立，或者其他线程无法唤醒这个线程而一直处于非运行状态（线程并未终止）导致其任务 一直无法进展。 线程死锁和线程锁死的外部表现是一致的，即故障线程一直处于非运行状态使得其所执行的任务没有进展。但是锁死的产生条件和线程死锁不一样
线程死锁是什么
热门推荐
Ai1114的博客
06-14 4万+
线程死锁：两个或两个以上的线程在执行过程中同时被阻塞，它们中的某个或者全部都在等待某个资源被释放，由于线程被无限期的阻塞，系统处于死锁状态或系统产生了死锁，这些永远在互相等待的线程被称为线程死锁 如上图所示，线程A持有资源2，线程B持有资源1，它们都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态 如果想要了解什么是线程阻塞的朋友，可以看我之前发的一篇线程的阻塞线程死锁示例代码如下： 线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通
java多线程的死锁问题
05-20
死锁是指两个或以上的线程在互相等待对方释放资源或锁的情况下陷入了无限阻塞的状态。Java中的多线程死锁问题通常是由于多个线程试图获取同一个锁的时候，出现了循环等待的情况。解决Java多线程死锁问题的方法有以下几种： 1. 避免嵌套锁，即在持有一个锁的时候，尽量避免再去请求另一个锁； 2. 尽量保证获取锁的顺序一致，避免不同线程之间出现获取锁的顺序不一致的情况； 3. 设置超时时间，当一个线程等待一个锁的时间超过一定时间后，就放弃该锁，防止出现死锁的情况； 4. 避免使用过多的同步代码块，尽量减少同步的范围，避免出现锁的竞争； 5. 使用Lock对象代替synchronized关键字实现锁竞争。 以上是几种比较常见的解决Java多线程死锁问题的方法，如果我们在编写多线程程序时注意这些细节，就可以有效避免多线程死锁问题的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值