多线程中什么是死锁？怎么避免死锁?怎么排查死锁？

最新推荐文章于 2023-12-19 08:12:10 发布

jiyishenlin

最新推荐文章于 2023-12-19 08:12:10 发布

阅读量360

点赞数

分类专栏：学习代码文章标签： java 开发语言

本文链接：https://blog.csdn.net/u011711878/article/details/124796071

版权

学习代码专栏收录该内容

6 篇文章 2 订阅

订阅专栏

java多线程

多线程的创建
线程的状态
线程方法start和run的区别
sleep和wait方法的区别
多线程同步有哪几种方法
多个线程，如何保证它们按顺序执行
什么是死锁？怎么避免死锁？
- 什么是死锁
- 怎么避免死锁
怎么排查死锁

多线程的创建

（1）继承 Thread 类实现多线程

public class MyThread {
    public static void main(String[] args) {
        System.out.println("start");
        new ThreadTest().start();
        System.out.println("end");
    }
}
class ThreadTest extends Thread{
    @Override
    public void run() {
        System.out.println("this is a thread");
    }
}

（2）实现 Runnable 接口方式实现多线程

public class MyThread {
    public static void main(String[] args) {
        System.out.println("start");
        new Thread(new ThreadTest()).start();
        System.out.println("end");
    }
}
class ThreadTest implements Runnable{

    @Override
    public void run() {
        System.out.println("this is a implements Runnable");
    }
}

（3）使用 Callable、Future 实现有返回结果的多线程

public class MyThread {
    public static void main(String[] args) throws Exception {
        System.out.println("start");
        ThreadTest3 threadTest3 = new ThreadTest3();
        FutureTask ft = new FutureTask<>(threadTest3);
        new Thread(ft).start();
        System.out.println("end");
    }
}
class ThreadTest3 implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println("this is a call");
        return "return this is a call";
    }
}

（4）通过线程池ExecutorService创建线程


public class MyThread {
    public static void main(String[] args) throws Exception {
        System.out.println("start");
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // 创建多个有返回值的任务
        List<Future> list = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            Callable c = new ThreadTest3(i);
            // 执行任务并获取Future对象
            Future f = pool.submit(c);
            list.add(f);
        }
        // 关闭线程池
        pool.shutdown();
        System.out.println("end");
    }
}
class ThreadTest3 implements Callable{
    private int num;
    ThreadTest3(int num){
        this.num=num;
    }
    @Override
    public Object call() throws Exception {
        System.out.println("线程：" + num + "开始运行");
        return "return this is a call";
    }
}

线程的状态

状态	说明
NEW	初始状态，线程被创建还没有调用start方法
RUNNABLE	运行状态，Java线程将操作系统中的就绪和运行两种状态笼统的称为“运行中”
BLOCKED	阻塞状态，表示线程阻塞于锁
WAITING	等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（notify，notifyall）
TIMED_WAITING	超时等待状态，该状态不同于WAITING，它是可以在指定时间自行返回的
TERMINATED	终止状态，表示当前线程已经执行完毕

在这里插入图片描述

线程方法start和run的区别

调用run方法是顺序执行，调用start方法才是交替执行。

sleep和wait方法的区别

1.sleep方法是Thread类的静态方法，wait是Object的方法。
2.sleep方法可在任意地方执行，wait只能在同步方法中执行。
3.sleep不会释放锁，wait会释放锁，sleep执行完会抢夺cpu，wait调用后不会自动唤醒，只能通过notify等方法唤醒。

多线程同步有哪几种方法

1.使用Synchronized 关键字修饰方法或代码块

2.使用关键字volatile修饰变量（可见性）
使用 volatile 关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到 volatile 变量，一定是最新的数据
3.使用Lock锁，在finally中释放锁

多个线程，如何保证它们按顺序执行

调用完start方法后调用join方法

public static void main(String[] args) throws Exception {
        System.out.println("start");
        Thread thread1 = new Thread(new ThreadTest2());
        Thread thread2 = new Thread(new ThreadTest2());
        Thread thread3 = new Thread(new ThreadTest2());
        thread1.start();
        thread1.join();
        System.out.println("thread1");
        thread2.start();
        thread2.join();
        System.out.println("thread2");
        thread3.start();
        thread3.join();
        System.out.println("thread3");
        System.out.println("end");
    }
    执行结果
    start
	this is a implements Runnable
	thread1
	this is a implements Runnable
	thread2
	this is a implements Runnable
	thread3
	end

什么是死锁？怎么避免死锁？

什么是死锁

两个线程为了保护两个不同的共享资源而使用了两个互斥锁，那么这两个互斥锁应用不当的时候，可能会造成两个线程都在等待对方释放锁，在没有外力的作用下，这些线程会一直相互等待，就没办法继续运行，这种情况就是发生了死锁。
死锁只有同时满足以下四个条件才会发生：
1.互斥条件
多个线程不能同时使用同一个资源
2.持有并等待条件
持有并等待条件是指，当线程 A 已经持有了资源 1，又想申请资源 2，而资源 2 已经被线程 C 持有了，所以线程 A 就会处于等待状态，但是线程 A 在等待资源 2 的同时并不会释放自己已经持有的资源 1。
3.不可剥夺条件
当线程已经持有了资源，在自己使用完之前不能被其他线程获取，线程 B 如果也想使用此资源，则只能在线程 A 使用完并释放后才能获取。
4.环路等待条件
在死锁发生的时候，两个线程获取资源的顺序构成了环形链。

怎么避免死锁

避免死锁问题就只需要破环4个条件中一个条件就可以，最常见的并且可行的就是使用资源有序分配法，来破环环路等待条件。
1.资源有序分配法

线程 A 和线程 B 获取资源的顺序要一样，当线程 A 是先尝试获取资源 A，然后尝试获取资源 B 的时候，线程 B 同样也是先尝试获取资源 A，然后尝试获取资源 B。也就是说，线程 A 和线程 B 总是以相同的顺序申请自己想要的资源。

2.超时放弃
当线程获取锁超时了则放弃，这样就避免了出现死锁获取的情况。当使用synchronized关键词提供的内置锁时，只要线程没有获得锁，那么就会永远等待下去，然而Lock接口提供了boolean tryLock(long time, TimeUnit unit) throws InterruptedException方法，该方法可以按照固定时长等待锁，因此线程可以在获取锁超时以后，主动释放之前已经获得的所有的锁。通过这种方式，也可以很有效地避免死锁。