活跃性问题（死锁）

最新推荐文章于 2021-06-26 11:06:40 发布
最新推荐文章于 2021-06-26 11:06:40 发布
阅读量195 收藏
点赞数
分类专栏： 线程并发 文章标签： 多线程 并发编程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeguangchen/article/details/108120921
版权

什么是死锁？

  1. 发生在并发里。

  2. 互不相让：当两个（或多个）线程（或进程）相互持有对方所需要的锁，又不主动释放，导致所有人都无法继续前进，导致程序陷入无尽的阻塞，这就是死锁。
    在这里插入图片描述

  3. 如果多个线程之间的依赖关系是环形，存在环路的锁的依赖关系，那么也可能发生死锁。
    在这里插入图片描述

  • 死锁的影响

  • 几率不高单危害大

必定发生死锁最简单的例子

/**
 * 必定发生死锁
 */
public class MustDeadLock implements Runnable{
    int flag = 1;
    static Object o1 = new Object();
    static Object o2 = new Object();

    public static void main(String[] args) {
        MustDeadLock r1 = new MustDeadLock();
        MustDeadLock r2 = new MustDeadLock();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
    @Override
    public void run() {
        System.out.println("flag = "+flag);
        if(flag == 1){
            synchronized (o1){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2){
                    System.out.println("线程1成功拿到两把锁");
                }
            }
        }

        if(flag == 0){
            synchronized (o2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1){
                    System.out.println("线程2成功拿到两把锁");
                }
            }
        }
    }
}

转账时候遇到死锁，一旦打开注释，就是发生死锁 例子

/**
 * 转账时候遇到死锁，一旦打开注释，就是发生死锁
 */
public class TransferMoney implements Runnable {
    private int flag = 1;
    static Account a = new Account(500);
    static Account b = new Account(500);

    public static void main(String[] args) throws InterruptedException {
        TransferMoney r1 = new TransferMoney();
        TransferMoney r2 = new TransferMoney();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("a的余额"+a.balance);
        System.out.println("b的余额"+b.balance);

    }
    @Override
    public void run() {
        if (flag == 1) {
            transferMoney(a, b, 200);
        }
        if (flag == 0) {
            transferMoney(b, a, 200);
        }
    }

    public static void transferMoney(Account from, Account to, int amount) {
        synchronized (from) {
//            try {
//                Thread.sleep(500);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            synchronized (to) {
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账结束。");
                }
                from.balance -= amount;
                to.balance += amount;
                System.out.println("成功转账"+amount +"元");
            }
        }
    }

    static class Account {
        public Account(int balance) {
            this.balance = balance;
        }
        int balance;
    }
}

多人转账死锁例子

/**
 * 多人同时转账，依然很危险（演示多人转账死锁）
 */
public class MultiTransferMoney {

    private static final int NUM_ACCOUNRS = 5000;
    private static final int NUM_MONEY = 1000;
    private static final int NUM_ITERATIONS = 1000000;
    private static final int NUM_THREADS = 20;

    public static void main(String[] args) {
        Random rnd = new Random();
        TransferMoney.Account[] accounts = new TransferMoney.Account[NUM_ACCOUNRS];
        for(int i =0; i<accounts.length;i++ ){
            accounts[i] = new TransferMoney.Account(NUM_MONEY);
        }
        class TransferThread extends Thread{
            @Override
            public void run(){
                for(int i = 0;i< NUM_ITERATIONS;i++){
                    int fromAcct = rnd.nextInt(NUM_ACCOUNRS);
                    int toAcct = rnd.nextInt(NUM_ACCOUNRS);
                    int amount = rnd.nextInt(NUM_MONEY);
                    TransferMoney.transferMoney(accounts[fromAcct],accounts[toAcct],amount);
                }
                System.out.println("运行结束");
            }
        }
        for(int i=0;i<NUM_THREADS;i++){
            new TransferThread().start();
        }
    }
}

* 死锁发生的4个必要条件（缺一不可）

  1. 互斥条件
  2. 请求与保持条件
  3. 不剥夺条件
  4. 循环等待条件
    判断程序死锁就对着这四点，都满足，就会发生死锁

检测定位死锁

  • jstake
  • ThreadMXBean
    代码演示
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

/**
 * 用ThreadMXBean检测死锁
 */
public class ThreadMXBeanDetection implements Runnable{

    int flag = 1;
    static Object o1 = new Object();
    static Object o2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        MustDeadLock r1 = new MustDeadLock();
        MustDeadLock r2 = new MustDeadLock();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);

        //用ThreadMXBean检测死锁
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        //拿到所有死锁线程id
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

        if(deadlockedThreads != null && deadlockedThreads.length > 0){
            for(int i = 0; i < deadlockedThreads.length ; i++){
                ThreadInfo threadInfo = threadMXBean.getThreadInfo(deadlockedThreads[i]);
                System.out.println("发现死锁了"+threadInfo.getThreadName());
            }
        }
    }
    @Override
    public void run() {
        System.out.println("flag = "+flag);
        if(flag == 1){
            synchronized (o1){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2){
                    System.out.println("线程1成功拿到两把锁");
                }
            }
        }

        if(flag == 0){
            synchronized (o2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1){
                    System.out.println("线程2成功拿到两把锁");
                }
            }
        }
    }
}

输出结果

flag = 1
flag = 0
发现死锁了Thread-1
发现死锁了Thread-0

修复策略

* 避免策略

  • 转账转换方案
    1. 实际上不在乎获取锁的顺序
    2. 通过hashCode来决定获取锁的顺序，冲突时需要“加时赛”
    3. 有主键更方便
/**
 * 修复转账死锁问题
 */
public class TransferMoney implements Runnable {
    private int flag = 1;
    static Account a = new Account(500);
    static Account b = new Account(500);
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        TransferMoney r1 = new TransferMoney();
        TransferMoney r2 = new TransferMoney();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("a的余额" + a.balance);
        System.out.println("b的余额" + b.balance);
    }

    @Override
    public void run() {
        if (flag == 1) {
            transferMoney(a, b, 200);
        }
        if (flag == 0) {
            transferMoney(b, a, 200);
        }
    }

    public static void transferMoney(Account from, Account to, int amount) {
        //编写一个帮助类
        class Helper {
            public void transfer() {
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账结束。");
                }
                from.balance -= amount;
                to.balance += amount;
                System.out.println("成功转账" + amount + "元");
            }
        }
        //获取两个对象的hashCode
        int fromHash = System.identityHashCode(from);
        int toHash = System.identityHashCode(to);
        //根据hash值大小不同加锁顺序调换
        if (fromHash < toHash) {
            synchronized (from) {
                synchronized (to) {
                    new Helper().transfer();
                }
            }
        } else if (fromHash > toHash) {
            synchronized (to) {
                synchronized (from) {
                    new Helper().transfer();
                }
            }
        } else {//当hash值一样
            synchronized (lock){
                synchronized (to) {
                    synchronized (from) {
                        new Helper().transfer();
                    }
                }
            }
        }

    }

    static class Account {
        public Account(int balance) {
            this.balance = balance;
        }
        int balance;
    }
}

哲学家就餐问题

  1. 问题描述
    在这里插入图片描述
    想吃饭，先拿起左手边的筷子，然后拿起右手边的筷子，如果筷子被人用了，那就等别人用完，吃完后加个筷子放回原位。

  2. 有死锁和耗尽资源风险

  3. 代码演示：哲学家进入死锁
    死锁：每个哲学家都拿起左手边的筷子，永远都在等右边的筷子（或者相反）

/**
 * 演示哲学家就餐导致死锁
 */
public class DiningPhilosophers {
    public static class Philosopher implements Runnable {

        private Object leftChopstick;
        private Object rightChopstick;

        public Philosopher(Object leftChopstick, Object rightChopstick) {
            this.leftChopstick = leftChopstick;
            this.rightChopstick = rightChopstick;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    doAction("Thinking");
                    synchronized (leftChopstick) {
                        doAction("Picked up left chopstick");
                        synchronized (rightChopstick) {
                            doAction("Picked up right chopstick -eating");

                            doAction("Picked down right chopstick");
                        }
                        doAction("Picked down left chopstick");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        private void doAction(String action) throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + " " + action);
            Thread.sleep((long) (Math.random() * 10));
        }
    }

    public static void main(String[] args) {
        Philosopher[] philosophers = new Philosopher[5];
        Object[] chopsticks = new Object[philosophers.length];
        for (int i = 0; i < chopsticks.length; i++) {
            chopsticks[i] = new Object();
        }

        for (int i = 0; i < philosophers.length; i++) {
            Object leftChopstick = chopsticks[i];
            Object rightChopstick = chopsticks[(i + 1) % chopsticks.length];
            philosophers[i] = new Philosopher(leftChopstick, rightChopstick);
            new Thread(philosophers[i], "哲学家" + (i + 1) + "号").start();
        }
    }
}

众多结果里的其中一种结果：

哲学家1号 Thinking
哲学家3号 Thinking
哲学家4号 Thinking
哲学家2号 Thinking
哲学家5号 Thinking
哲学家2号 Picked up left chopstick
哲学家4号 Picked up left chopstick
哲学家1号 Picked up left chopstick
哲学家3号 Picked up left chopstick
哲学家5号 Picked up left chopstick
  1. 多种解决方案
    a. 服务员检查（避免策略），相当于引入了外界的协调
    b. 改变一个哲学家拿筷子的顺序(避免策略)
    c.餐票（避免策略）每个人只能拿到餐票才能吃，5个人吃饭，我们只提供4个餐票
    d.领导调节（检测与恢复策略）相当于当死锁有有一个机制能让某个人释放资源
  2. 代码演示：解决死锁
/**
* 避免策略：哲学家就餐的换手方案
* b. 改变一个哲学家拿筷子的顺序(避免策略)
 * 只贴出主方法，因为其他代码合上面的一致
 * 主要看这个if里的初始化哲学家的代码 if(i == philosophers.length - 1){
 */
public static void main(String[] args) {
        Philosopher[] philosophers = new Philosopher[5];
        Object[] chopsticks = new Object[philosophers.length];
        for (int i = 0; i < chopsticks.length; i++) {
            chopsticks[i] = new Object();
        }

        for (int i = 0; i < philosophers.length; i++) {
            Object leftChopstick = chopsticks[i];
            Object rightChopstick = chopsticks[(i + 1) % chopsticks.length];
            if(i == philosophers.length - 1){
                //让其中一个哲学家拿筷子的顺序相反
                philosophers[i] = new Philosopher(rightChopstick, leftChopstick);
            }else{
                philosophers[i] = new Philosopher(leftChopstick, rightChopstick);
            }
            new Thread(philosophers[i], "哲学家" + (i + 1) + "号").start();
        }
    }

常见修复策略

  • 避免策略：****哲学家就餐的换手方案。转账换序方案
  • 检测与恢复策略：一段时间检测是否有死锁，如果有就剥夺其中一个资源，来打开死锁
  • 鸵鸟策略：如果我们发生死锁的几率非常低，处理成本大，就可以直接忽略它，直到死锁发生后再人工修复

实际工程中如何避免死锁

  1. 设置超时时间

    • Lock的tryLock(long timeout,TimeUnit unit)（后面有代码演示）。
    • synchronized不具备尝试锁的能力。
    • 造成超时的可能性很多：发生了死锁、线程进入了死循环、线程本身就执行很慢。
    • 获取锁失败：打日志、发警报邮件、重启等

  2. 多使用并发类而不是自己设计锁

    • ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等。
    • 实际应用中java.util.concurrent.atomic是非常有用的，简单方便且效率比使用Lock更高。
    • 多用并发集合少用同步集合，并发集合比同步集合的可扩展性更好 。
    • 并发场景需要用到Map，首先想到用ConcurrentHashMap。

  3. 降低锁的力度：用不同的锁，而不是一个锁。

  4. 如果能使用同步代码块，就不使用同步方法：自己指定锁的对象。

  5. 给你的线程起个有意义的名字：debug和排查时事半功倍，框架和JDK都遵循这个最佳实践。

  6. 避免锁的嵌套：如上面的MustDeadLock 类。

  7. 分配资源前先看能不能收回来：银行家算法

  8. 尽量不要几个功能使用同一把锁：专锁专用

Lock的tryLock避免死锁的代码演示

/**
 * 用tryLock避免死锁
 */
public class TryLockDeadLock implements Runnable{
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();
    private int flag = 1;

    public static void main(String[] args) {
        TryLockDeadLock r1 = new TryLockDeadLock();
        TryLockDeadLock r2 = new TryLockDeadLock();
        r1.flag = 1;
        r1.flag = 0;
        new Thread(r1).start();
        new Thread(r2).start();
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(flag == 1){
                try {
                    if(lock1.tryLock(800, TimeUnit.MILLISECONDS)){
                        System.out.println("线程1获取到了锁1");
                        if(lock2.tryLock(800,TimeUnit.MILLISECONDS)){
                            System.out.println("线程1获取到了锁2");
                            System.out.println("线程1获取到了两把锁");
                            lock2.unlock();
                            lock1.unlock();
                            break;
                        }else {
                            System.out.println("线程1尝试锁2失败，已重试");
                            lock1.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    }else{
                        System.out.println("线程1获取锁1失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if(flag == 0){
                try {
                    if(lock2.tryLock(3000, TimeUnit.MILLISECONDS)){
                        System.out.println("线程2获取到了锁2");
                        if(lock1.tryLock(3000,TimeUnit.MILLISECONDS)){
                            System.out.println("线程2获取到了锁1");
                            System.out.println("线程2获取到了两把锁");
                            lock2.unlock();
                            lock1.unlock();
                            break;
                        }else {
                            System.out.println("线程2尝试锁1失败，已重试");
                            lock1.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    }else{
                        System.out.println("线程2获取锁2失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

上篇：单例模式的8种写法
下篇：活跃性问题（活锁、饥饿）

叶光尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程之活跃性危险.docx
06-21
在安全性和活跃性之间存在某种制衡，我们使用加锁机制来确保线程安全，但是过度使用加锁，或使用不当，可能导致活跃性故障，最严重的情况下导致死锁。 1.1 死锁 在线程A持有锁L的同时，又想继续持有锁R；而线程B持有...
static 使用
清扬叶
06-21 519
public class StaticTest { // 静态变量 类加载时执行 只执行一次 // 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便） private static int flag = 1; // 对于变量，若使用static final修饰，表示一旦赋值不能修改，并且通过类名
活跃性问题:死锁、活锁、饥饿
as513385的博客
04-08 265
什么是死锁 1.发生在并发中 2.互不相让:当两个(或更多)线程相互持有对方需要的资源,又不主动释放,导致所有线程都无法继续进行,使得两个(或多个)线程陷入无限的阻塞,这就是死锁 两个线程造成的死锁 public class DeadLock { public static void main(String[] args) throws InterruptedException { new Thread(DeadLock::command).start(); new
什么是活跃性？及常见活跃性问题
热门推荐
TOOCRUEL
03-09 1万+
一个并发应用程序能及时执行的能力称为活跃性。 A concurrent application’s ability to execute in a timely manner is known as its liveness. 死锁 死锁描述了这样一种情景，两个或多个线程永久阻塞，互相等待对方释放资源。下面是一个例子。 Alphone和Gaston是朋友，都很讲究礼节。礼节有一个严...
活跃性（死锁、饥饿、活锁）
傻傻的青铜的博客
07-05 2694
锁顺序死锁我们知道，加锁是为了保证线程安全性而做的同步操作，而过度的加锁可能导致各个线程彼此依赖别的线程已经持有的锁。先上一段代码瞅瞅：public class DeadLockDemo {    public static void main(String[] args) {        Object lock1 = new Object();        Object lock2 = ne...
《java并发编程实战》笔记之避免活跃性危险
qq_36962925的博客
08-25 137
文章目录**引言****活跃性****活跃性故障****死锁****死锁避免与诊断****饥饿****活锁****丢失信号** 引言 本文属于作者笔记，知识点来自《java并发编程实战》。 活跃性 一个并发应用程序能及时执行的能力称为活跃性。 活跃性故障 活跃性故障是指为确保线程安全性过度使用加锁而使程序无法继续执行下去的原因。这些原因包括：死锁（最常见得活跃性故障）、饥饿、丢失信号和活锁。 死锁...
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 ... 线程活跃与线程饥饿 同步工具类 原子操作类 AtomicInteger等 相当于加上synchronized 也有些利用硬件底层能力CAS
（WSPR）-P-3的活力：复杂性和决策
05-09
我们首先根据分区问题证明（WSPR）-P-3的活跃性问题是共NP难题。 此外，我们基于两个新概念（结构循环等待（SCW）和阻塞标记（BM））为（WSPR）-P-3的生命力提供了充要条件，即（WSPR）-P-3为如果每个SCW没有BM，则...
面试JAVA程序员常遇到的一些问题.pdf，这是一份不错的文件
06-09
1. 项目并发处理：使用线程池控制并发数量，配合synchronized、Lock等同步机制保证数据一致性，避免死锁和活锁。 2. 功能权限漏洞：水平权限漏洞指用户能访问本不应该访问的同级资源，垂直权限漏洞指用户越权访问高...
项目中辅助工具类
张小贝的博客
12-20 901
缓存工具类public class ACache { public static final int TIME_HOUR = 60 * 60;// public static final int TIME_DAY = TIME_HOUR * 24; private static final int MAX_SIZE = 1000 * 1000 * 50; // 50 mb private
各修饰符final ,static的使用
qq_41988977的博客
04-19 358
final 有三种使用场景，分别是修饰变量、方法和类，无论哪种修饰，一旦声明为final类型，你将不能改变这个引用了，编译器会检查代码，如果你试图再次初始化，编译器会报错 1、修饰变量  当final修饰一个变量的时候一般把他作为常量，通常和static关键字配合使用。例如：  private static final String ISSUCCESS_FLAG = “true”;一般st
活跃性问题（活锁、饥饿）
yeguangchen的博客
08-21 269
死锁是最常见的活跃性问题，不过除了死锁之外，还有一些类似的问题，会导致程序无法顺利执行，统称为活跃性问题。 活锁 什么是活锁 虽然线程没有阻塞，也始终在运行，但是程序却得不到进展，因为始终在做重复的事 代码演示 /** * 演示活锁问题 */ public class LiveLock { //勺子类 static class Spoon { //勺子所属这 private Diner owner; public Spoon(Di.
线程的活跃性问题
hncboy的博客
11-15 933
前面我们了解了多线程带来的安全性问题，接下来我们来看下多线程带来的活跃性问题。 一、活跃性问题 线程是为任务而生的，理想情况下，我们希望线程能一直处于运行（Runnable）状态，但是会由于一些因素，如处理器资源有限导致的上下文切换、程序自身的错误和缺陷。这些由于资源稀缺或者程序自身问题导致线程无法一直处于 Runnable 状态运行下去，又或者因为线程处于 Runnable 状态但是其要执行的任务一直无法进展的现象就被称为线程活跃性问题或活性故障。我们常见的“死锁”就是一种典型的活跃性问题，除了“死锁”，
锁活跃性问题（死锁，饥饿、活锁）
l1394049664的博客
07-29 1203
一、死锁         每个人都拥有其他人需要的资源，同时又等待其他人已经拥有的资源，并且每个人在获取所有需要的资源之前都不会放弃已经拥有的资源。         当一个线程永远地持有一个锁，并且其他线程都尝试去获得这个锁时，那么它们将永远被阻塞，这个我们都知道。如果线程A持有锁L并且想获得锁M，线程B持有锁M并且想获得锁L，那么这两个线程将永远等待下去，这种情况就是最简单的死锁形式。其中多...
死锁（触发条件）
qq_39438055的博客
06-26 282
所谓死锁，是多个线程在运行过程中因争夺资源而造成的一种僵局 触发的四大条件： - 互斥锁 - 请求与保持 - 不可剥夺 - 循环的请求与等待。 如何写一个死锁 public class DeadLock { public static void main(String[] args) { Object a = new Obejct(); Object b = new Obejct(); new Thread(new Resource(a,b)..
线程4个属性
yeguangchen的博客
08-16 2960
线程4个属性 线程ID：每个线程都有自己的ID，用来标识不同的线程。JVM就用ID辨识线程，这个属性虽然在每一次JVM启动是唯一的，下一次创建线程，它又会从1开始往上编号，所以同一个ID会被先后不同的线程使用，唯一性不能保证；ID不允许被修改。ID是从1开始，并自增的，JVM运行起来后，我们自己创建的线程ID早已经不是1也不等于2，因为JVM 会自动创造一些线程，比如去做初始化、gc等。Thread.currentThread().getId(); 线程Name：作用是让程序员在开发、调试或运行过程中，更容
Thread的常用方法sleep和join详解
yeguangchen的博客
08-16 2094
sleep方法可以让线程进入到Waiting状态，并且不占用CPU资源，但是不释放锁，知道规定时间后再执行，休眠期间如果没中断，会抛出异常并清除中断状态。 sleep()和wait()区别 1.sleep对比wait最大的区别就是sleep不释放锁，包括synchronized和lok。而wait会释放锁。 2.sleep()在Thread类里，wait()在Object类里，wait()，notifyAll()，notify()在Object对象里，因为这三个是锁级别的操作，而锁是属于某个对象的，每个对象
创建线程的两个方法（Oracle官网说两种）
yeguangchen的博客
08-09 1643
一.有多少种实现多线程的方法？ 1.不同的角度有不同的答案 2.典型的答案有两种，分别是实现Runnable接口和继承Thread类 3.但是看原理，其实Thread类实现了Runnable接口，并且看Thread类的run方法，会发现其两者本质是一样的，run方法发代码如下： @Override Public void run(){ if(target != null){ target.run(); } } 方法1和方法2，也就是说“实现Runnable类”和“继承Thread类然后重写run(
处理线程未捕获的异常UncaughtExceptionHandler
yeguangchen的博客
08-16 1118
为什么需要UncaughtExceptionHandler？ 1.主线程可以轻松发现异常，子线程却不行（比如子线程抛出了RuntimeException异常，而主线程start子线程后后续还有很多逻辑，子线程的异常可能夹杂在日志里无法轻松发现）。 2.子线程异常无法用传统方法捕获（比如在主方法里try/catch不能捕获到子线程里面的异常，他只能捕获主线程的异常）。 处理多线程子线程的异常有两种方式： 第一种是手动在每个run方法里进行try/catch,不推荐这种方式，写起来繁琐。 第二种是利用Uncau
mysql死锁如何排查
最新发布
06-12
- 对于已经识别出的死锁事务，可以通过`KILL`命令强制结束，但需要谨慎，因为这可能破坏数据一致性。 6. **锁定策略调整**： - 检查应用程序的锁定策略，确保不会无意识地创建死锁条件，比如避免循环依赖锁。 7....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值