死锁_线程池

最新推荐文章于 2023-08-16 09:57:12 发布

皮卡丘不断更

最新推荐文章于 2023-08-16 09:57:12 发布

阅读量346

点赞数

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/PIKapikaaaa/article/details/123416248

版权

Java基础专栏收录该内容

37 篇文章 1 订阅

订阅专栏

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