死锁_线程池

关注

原创最新推荐文章于 2026-03-29 03:18:50 发布 446 阅读 AI 写同款· GEO 优化 ›

线程池自引发死锁 线程池自引发死锁死锁是由许多线程锁定相同资源引起的如果在该池中运行的任务内使用线程池，也会发生死锁像RxJava / Reactor这样的现代图书馆也很容易受到影响死锁是两个或多个线程正在等待彼此获取的资源的情况。例如，线程A等待lock1线程B锁定，而线程B等待lock2，由线程A锁定。在最坏的情况下，应用程序冻结无限期的时间。让我向您展示一个具体的例子。想象一下，有一个Lumberjack类可以保存对两个附件锁的引用： import com.google.common.colle 阅读详情

Lock锁

概述：

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是并不能直观看到线程在哪里获取了锁，在哪里释放了锁，所以为了更清晰的展示如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，可以使用此对象，来表示锁的创建和释放。

特点：

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
同步代码块、同步方法、以及Lock锁的默认创建方式都是非公平情况
再创建Lock锁对象时，可以将参数传递true，那么该锁就变为一个公平锁，一旦变为公平锁之后，每个线程都有被执行的机会。

构造方法：ReentrantLock()：创建一个ReentrantLock的实例

加锁解锁方法：

void lock() ：获得锁
void unlock()：释放锁

例：卖火车票：
需求：
模拟火车站卖票方式，完成如下需求：
（1）定义三个窗口，模拟三个窗口同时售卖一百张火车票，在卖票之后，在控制台展示卖票结果，当第100张票卖出后，结束程序即可。
（2）比如：
窗口1卖出一张票，还剩99张票
窗口1卖出一张票，还剩98张票
窗口3卖出一张票，还剩97张票
窗口2卖出一张票，还剩96张票
……
窗口1卖出一张票，还剩0张票

public class homework01 {
    static  int tic = 100;
    public static void main(String[] args) {
        Runnable r =new Runnable() {
            //创建锁对象，布尔值为true的时候是代表一个公平锁，每个线程都有机会执行
            ReentrantLock reen = new ReentrantLock(true);
            @Override
            public void run() {
                while (true) {
                    try{
                        //获取锁对象
                        reen.lock();
                        if (tic < 1) return;
                        tic = tic - 1;
                        System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + tic + "张票");
                    }finally {
                        //释放锁对象
                        reen.unlock();
                    }

                }
            }
        };
            Thread t1 = new Thread(r, "窗口1");
            Thread t2 = new Thread(r, "窗口2");
            Thread t3 = new Thread(r, "窗口3");
            t1.start();
            t2.start();
            t3.start();
    }
}

死锁

死锁概述：

线程死锁是指由两个或者多个线程互相持有并且需要对方的的资源（锁），导致这些线程处于等待状态，无法前往执行

问题：

线程A：需要获取到锁x以及锁y 线程A获取到x锁，需要锁y才可以执行
线程B：需要获取到锁x以及锁y 线程B获取到y锁，需要锁x才可以执行

解决：

可以让线程A和线程B先抢同一支筷子，拿到第一支筷子的线程，才能获取第二支筷子。如果线程第一支筷子没有拿到，没有机会拿第二支筷子

图示：

Lock锁

概述：

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是并不能直观看到线程在哪里获取了锁，在哪里释放了锁，所以为了更清晰的展示如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，可以使用此对象，来表示锁的创建和释放。

特点：

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
同步代码块、同步方法、以及Lock锁的默认创建方式都是非公平情况
再创建Lock锁对象时，可以将参数传递true，那么该锁就变为一个公平锁，一旦变为公平锁之后，每个线程都有被执行的机会。

构造方法：ReentrantLock()：创建一个ReentrantLock的实例

加锁解锁方法：

void lock() ：获得锁
void unlock()：释放锁

例：卖火车票：
需求：
模拟火车站卖票方式，完成如下需求：
（1）定义三个窗口，模拟三个窗口同时售卖一百张火车票，在卖票之后，在控制台展示卖票结果，当第100张票卖出后，结束程序即可。
（2）比如：
窗口1卖出一张票，还剩99张票
窗口1卖出一张票，还剩98张票
窗口3卖出一张票，还剩97张票
窗口2卖出一张票，还剩96张票
……
窗口1卖出一张票，还剩0张票

public class homework01 {
    static  int tic = 100;
    public static void main(String[] args) {
        Runnable r =new Runnable() {
            //创建锁对象，布尔值为true的时候是代表一个公平锁，每个线程都有机会执行
            ReentrantLock reen = new ReentrantLock(true);
            @Override
            public void run() {
                while (true) {
                    try{
                        //获取锁对象
                        reen.lock();
                        if (tic < 1) return;
                        tic = tic - 1;
                        System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + tic + "张票");
                    }finally {
                        //释放锁对象
                        reen.unlock();
                    }

                }
            }
        };
            Thread t1 = new Thread(r, "窗口1");
            Thread t2 = new Thread(r, "窗口2");
            Thread t3 = new Thread(r, "窗口3");
            t1.start();
            t2.start();
            t3.start();
    }
}

死锁

死锁概述：

线程死锁是指由两个或者多个线程互相持有并且需要对方的的资源（锁），导致这些线程处于等待状态，无法前往执行

问题：

线程A：需要获取到锁x以及锁y 线程A获取到x锁，需要锁y才可以执行
线程B：需要获取到锁x以及锁y 线程B获取到y锁，需要锁x才可以执行

解决：

可以让线程A和线程B先抢同一支筷子，拿到第一支筷子的线程，才能获取第二支筷子。如果线程第一支筷子没有拿到，没有机会拿第二支筷子

图示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8x8n98A7-1646963480445)(C:\Users\12994\Desktop\笔记整理\21_死锁_线程池_单例.assets\wps5CB7.tmp.jpg)]

代码：

public static void main(String[] args) throws InterruptedException {
    String s1 = "左筷子";
    String s2 = "右筷子";
    Thread th1 =new Thread(){
        @Override
        public void run() {
            synchronized (s1){
                System.out.println("A拿到了"+s1+",等待"+s2);
                synchronized (s2){
                    System.out.println("A都拿到了，可以吃饭");
                }
            }
        }
    };
    Thread th2 = new Thread(){
        @Override
        public void run() {
            synchronized (s2){
                System.out.println("B拿到了"+s2+",等待"+s1);
                synchronized (s1){
                    System.out.println("B都拿到了，可以吃饭");
                }
            }
        }
    };
    th1.start();
    th2.start();
}

线程的生命周期

线程从创建到销毁的过程就是线程的生命周期

再线程的生命周期中有很多状态的描述

线程生命周期中的状态

新建态：线程对象刚创建好的状态
就绪态：线程启动之后，等待cpu来执行的状态
运行态：正在被cpu执行的状态
阻塞态：即使cpu来执行该线程，该线程也无法执行的状态

等待锁线程休眠 IO数据
死亡态（消亡）：线程正常将任务执行完成，或者碰到异常意外销毁

线程状态之间的关系：

在这里插入图片描述

获取线程的状态

以上所说的线程的状态，都是理论分析的状态，如果需要在代码中获取线程的状态，可以获取。

获取线程状态的方法：getState()

特点：该方法的返回值是Thread类中的内部类：State，该类型是一个枚举类，该类中定义了六个对象，来表示线程的六种状态对象。

罗列：

NEW：新建态
RUNNABLE：就绪态或者运行态
BLOCKED：阻塞态 IO数据导致的阻塞
WAITING：阻塞态 wait方法导致的阻塞
TIMED_WAITING：阻塞态 sleep方法导致的阻塞态
TERMINATED：死亡态

public static void main(String[] args) {
    Thread t = new Thread(){
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("----");
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    //获取线程状态：新建态
    Thread.State s = t.getState();
    System.out.println(s);
    //获取线程状态：可能是就绪或者运行态、阻塞态、死亡态
    t.start();
    Thread.State s1 = t.getState();
    System.out.println(s1);
}

线程池

概述：用来存储线程的一个容器

使用线程池的原因：

如果Java语言不支持线程池：
- 想要使用新线程完成任务，自己创建一个线程对象，将任务对象提交给线程对象，启动线程，完成任务，当任务完成之后，该线程对象就会被销毁。如果程序种有很多任务，就需要花费很多的时间在线程的创建和销毁上，就降低了程序的运行效率。反复的对线程创建和销毁造成了资源的浪费。
- 如果某条线程在执行任务的过程中，该线程被意外销毁了，那么就导致任务无法完成。
如果Java语言提供了线程池：
- 想要完成多个任务，不需要自己新创建线程对象，直接从线程池种获取线程来完成任务，解决创建线程对象的时间；当线程池种的线程完成任务之后，将该线程对象回收到线程池种，以后可以反复使用，避免了资源的浪费；如果线程池种的线程在完成任务的过程种被意外销毁，如果被销毁，线程池会继续分配线程完成该任务。

线程池的使用

步骤：

获取线程池对象
创建任务类对象
将任务对象提交给线程池
关闭线程池对象

获取线程池对象：

Executors：工具类获取线程池的工具类
newSingleThreadExecutor() ：获取一个具有单个线程的线程池对象
newFixedThreadPool(int n) ：获取一个有n条线程的线程池对象
newCachedThreadPool() ：获取一个线程池对象，根据提交的任务分配线程

将任务提交给线程池对象：

submit(Runnable r);

如果线程池种的线程少，任务多；存在的线程先并发完成任务，那一条线程先完成任务，就继续做等待的任务。
如果线程池种线程多，任务少：首先随机分配线程去并发完成提交的任务，多余的线程等待任务的提交。

private static void test02() {
    //获取一个线程池对象：并指定线程池中的线程条数
    //-------当线程数量多余任务数的时候，有的不执行
    //-------当线程数量少于任务书的时候，先执行完的线程在执行没被执行的任务
    ExecutorService three = Executors.newFixedThreadPool(4);

    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("任务1-----"+Thread.currentThread().getName());
        }
    };

    Runnable r2 = new Runnable() {
        @Override
        public void run() {
            System.out.println("任务2-----"+Thread.currentThread().getName());
        }
    };
    Runnable r3 = new Runnable() {
        @Override
        public void run() {
            System.out.println("任务3-----"+Thread.currentThread().getName());
        }
    };

    //把任务提交线程
    three.submit(r1);
    three.submit(r2);
    three.submit(r3);
    //关闭线程池，关闭之后不能再继续提交任务
    three.shutdown();
}

如果线程池中线程和任务一样多，线程之间并发完成任务。

//获取一个线程池对象：不指定线程数量，根据任务数量自动为其分配
        ExecutorService es = Executors.newCachedThreadPool();
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("任务1-----"+Thread.currentThread().getName());
            }
        };

        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("任务2-----"+Thread.currentThread().getName());
            }
        };
     

        es.submit(r1);
        es.submit(r2);
        //关闭线程池，关闭之后不能再继续提交任务
        es.shutdown();

关闭线程池的方法:

shutdown() ：将已经提交的任务全部完成之后，再关闭线程池。关闭后，不能再提交
shutdownNow() ：将正在运行的任务完成之后，关闭线程池。已经提交还没运行的任务，不再运行。

//把任务提交线程池，但是线程池中只有两个线程
three.submit(r1);
three.submit(r2);
three.submit(r3);
//关闭线程池，关闭之后不能再继续提交任务
three.shutdown();
//关闭后，r3任务也还没有运行
three.shutdownNow();

代码：

public static void main(String[] args) throws InterruptedException {
    String s1 = "左筷子";
    String s2 = "右筷子";
    Thread th1 =new Thread(){
        @Override
        public void run() {
            synchronized (s1){
                System.out.println("A拿到了"+s1+",等待"+s2);
                synchronized (s2){
                    System.out.println("A都拿到了，可以吃饭");
                }
            }
        }
    };
    Thread th2 = new Thread(){
        @Override
        public void run() {
            synchronized (s2){
                System.out.println("B拿到了"+s2+",等待"+s1);
                synchronized (s1){
                    System.out.println("B都拿到了，可以吃饭");
                }
            }
        }
    };
    th1.start();
    th2.start();
}