多线程进阶（其实困住你的不是他，是你和他的回忆）

已于 2023-07-16 14:31:21 修改
阅读量100 收藏
点赞数
文章标签： java jvm 开发语言
于 2023-06-05 15:48:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Biecaijinggai_/article/details/131049395
版权
文章介绍了Java中的线程死锁现象，包括产生原因和避免策略。接着讲解了线程通信的生产者消费者模式，使用Object的wait和notify方法实现。此外，还探讨了线程的sleep和wait方法的区别，以及阻塞队列的概念和使用。最后，详细讨论了线程池的原理，包括Executors的默认线程池和自定义ThreadPoolExecutor的配置。
摘要由CSDN通过智能技术生成

目录

1. 死锁

2. 线程通信

2.1 生产者和消费者模式概述

1. 概述

2. Object类的等待和唤醒方法

代码实现：

2.2 sleep和wait的区别

3. 阻塞队列基本使用

4. 线程的状态

5. 线程池

5.1 Executors默认线程池

5.2 ThreadPoolExecutor（阿里建议使用）

1. 死锁

  • 概述

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

  • 什么情况下会产生死锁
    • 资源有限
    • 同步嵌套
  • 代码
public class Demo {
    public static void main(String[] args) {
        //1.创建两个锁对象
        Object a = new Object();
        Object b = new Object();

        new Thread(() -> {
            while (true) {
                synchronized (a) {
                    //线程一
                    synchronized (b) {
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                synchronized (a) {
                    //线程一
                    synchronized (b) {
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

如何避免死锁:

  1. 尽量不要使用锁的嵌套。
  2. 不要使用锁，而使用安全类。java.util.concurrent下的类
  3. 设置锁的超时时间。Lock锁。到达指定时间没有获取锁，则不会再等待该锁。

2. 线程通信

2.1 生产者和消费者模式概述

1. 概述

生产者消费者模式是一个十分经典的多线程协作的模式

所谓生产者消费者问题，实际上主要是包含了两类线程：

  • 一类是生产者线程用于生产数据
  • 一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

2. Object类的等待和唤醒方法

代码实现：

/**
 * 桌子类
 * 定义表示包子数量的变量,
 * 定义锁对象变量,
 * 定义标记桌子上有无包子的变量
 */
public class Desk {
    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;

    //汉堡包的总数量
    public static int count = 10;

    //锁对象
    public static final Object lock = new Object();
}


/**
 * 厨师类
 * 实现Runnable接口，重写run()方法，设置线程任务
 */
public class Cooker implements Runnable {
    @Override
    public void run() {

        while (true) {
            synchronized (Desk.lock) {
                //判断桌子上是否有包子
                if (Desk.count == 0) {
                    break;
                } else {
                    //桌子上没有有包子，生产者开始制作
                    if (!Desk.flag) {
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        //更新包子的状态
                        Desk.flag = true;
                        //唤醒等待的吃货线程
                        Desk.lock.notifyAll();
                    } else {
                        //桌子上有包子，生产者进入等待队列  等待消费者吃完
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}


/**
 * 消费者类
 * 实现Runnable接口，重写run()方法，设置线程任务
 */
public class Foodie implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    //此时桌子上有包子
                    if (Desk.flag) {
                        //有则开吃
                        System.out.println("吃货在吃汉堡包");
                        //吃完改变包子状态
                        Desk.flag = false;
                        //吃后唤醒等待的生产者线程 叫醒厨师
                        Desk.lock.notifyAll();
                        //包子数量减一
                        Desk.count--;
                    } else {
                        //没有包子的就进入等待队列
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}


public class Test {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
        5，叫醒等待的生产者继续生产
        汉堡包的总数量减一*/

        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Foodie f = new Foodie();
        Cooker c = new Cooker();

        Thread f1 = new Thread(f);
        Thread c1 = new Thread(c);

        f1.start();
        c1.start();
    }
}

2.2 sleep和wait的区别

1. wait需要使用notify或notifyAll唤醒，而sleep到时间自动唤醒。

2. wait来自于Object类中，sleep来自Thread类中

3. wait会是否锁资源，sleep不会释放锁资源。

4. wait必须放在同步代码中，而sleep可以放在任意位置。

3. 阻塞队列基本使用

常见BlockingQueue:

        ArrayBlockingQueue: 底层是数组,有界

        LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

BlockingQueue的核心方法:

        put(anObject): 将参数放入队列,如果放不进去会阻塞

        take(): 取出第一个数据,取不到会阻塞

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列对象
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(1);
        // 存储元素
        queue.put("汉堡包");
        //取元素
        System.out.println(queue.take()); //1.能取到
        System.out.println(queue.take()); // 取不到就会阻塞
        System.out.println("程序结束了。。。。。。。。");
    }
}

4. 线程的状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。

NEW：新建状态。当new一个线程对象时进入该状态。

RUNNABLE:运行状态。调用完start并获取cpu时间片进入运行状态

BLOCKED: 堵塞状态。当没有获取锁资源时

WAITING: 当执行了wait方法时，该线程进入等待状态。

TIMED_WAITING:当执行sleep方法时，进入该状态

TERMINATED: 终止。 当线程执行完毕或出现异常中断。

5. 线程池

线程池也是可以看做成一个池子，在该池子中存储很多个线程。

线程池存在的意义：

系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系

统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就

会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

5.1 Executors默认线程池

概述 :

JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。

静态方法：

static ExecutorService newCachedThreadPool() 创建一个默认的线程池

static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

代码：

package com.aaa.a08mythreadpool;

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

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        //1.固定长度的线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(5);

//        for (int i = 0; i < 15; i++) {
//            executorService.submit(() -> System.out.println(Thread.currentThread().getName() + "正在执行====="));
//        }
        
        //2. 可变线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();

        //3. 单一线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        //4. 延迟线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("定时执行任务。。。");
            }
        }, 5, TimeUnit.SECONDS); // 5秒后执行

    }
}

5.2 ThreadPoolExecutor（阿里建议使用）

线程池中参数的意思.

core: 核心线程数

max: 最大线程池数

long: 等待时长

unit: 等待单位

BlockQueue:等待队列对象。

package com.aaa.a08mythreadpool;

import java.util.concurrent.*;

/**
 * 阿里巴巴建议
 */
public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建阻塞队列对象 其实就是允许等待的线程数量
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(3);

        //int corePoolSize,核心线程数
        //int maximumPoolSize,最大的个数
        // long keepAliveTime,等待时间长
        //TimeUnit unit,时间单位---
        //BlockingQueue<Runnable> workQueue: 等待队列
        ExecutorService executor = new ThreadPoolExecutor(3, 5, 10, TimeUnit.SECONDS, queue);

        for (int i = 0; i < 8; i++) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行");
                }
            });
        }

    }
}

IT阿舒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值