当前位置： 首页 > article >正文

【JavaEE】——多线程常用类

article 2024/10/1 16:35:46

 8e19eee2be5648b78d93fbff2488137b.png

阿华代码，不是逆风，就是我疯

你们的点赞收藏是我前进最大的动力！！

希望本文内容能够帮助到你！！

目录

引入：

一：Callable和FutureTask类

1：对比Runnable

2：FutureTask类

3：代码示例

示例一：Runnable

​编辑示例二：Callable

二：ReentrantLock——可重入锁

1：与synchronized的区别

（1）不会阻塞

（2）公平锁

（3）唤醒机制不同

三：Semaphore——信号量

1：P操作

2：V操作

3：PV代码示例一

4：锁功能

四：CountDownLatch

1：引入

2：代码示例

引入：

通过之前的学习，我们了解到CAS本质上是JVM替我们封装好的，我们没有办法感知到

在java.util.concurrent中存放了一些我们多线程编程时常用的类

看下面的一些接口：是不是非常熟悉，我们把这个packet包简称为（JUC）

e9ca2cbd045a46b1bbf59c50a57bf57b.png

一：Callable和FutureTask类

读法：“开了波哦”    译为：调用

1：对比Runnable

Runnable提供run方法，返回值为void——关注过程，不关注执行结果

Callable提供call方法，返回值类型就是执行结果的类型———更关注结果

2：FutureTask类

在Callable中的call方法中完成任务的描述后，我们要想办法把这个任务加载给线程Thread，

但是Thread类中并没有给出Callable的构造方法，于是我们通过FutureTask这个中间类（可以理解为加载任务的装置），作为媒介，发射给Thread

即：

Callable中描述方法——卢本伟来啦~~

FutureTask中加载任务——卢本伟已准备就绪~~

Thread中传入futureTask任务执行——卢本伟启动！！

注：

Callable和FutureTask实例化的时候<>中要写返回结果的类型哦。

futureTask.get()方法是带有阻塞功能的，如果线程还没有执行完毕，get就会被阻塞，等到线程执行完了，return的结果就会被get返回回来

3：代码示例

老问题：计算前5000个数字之和
 

看以下两段代码——用Callable类写的代码比Runnable类写的代码更加优雅~~

示例一：Runnable

package thread;


public class ThreadDemon37 {
    private static int sum = 0;//全局变量用来保存最后的结果值
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            int count = 0;//局部变量
            @Override
            public void run() {
                for (int i = 1 ; i <= 5000 ; i++){
                    count += i;
                }
                sum = count;
            }
        });
        t1.start();
        t1.join();
        System.out.println(sum);
    }


}

c187a3ca91944a6bab8894d443652fed.png示例二：Callable

此处我们不用再引入额外的成员变量了，直接借助返回值即可

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class ThreadDemon38 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 5000; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //Thread t1 = new Thread(callable);//Thread中没有提供构造函数来传入callable
        //引入FutureTask类，未来要完成的任务（任务还未执行）
        // 相当于在Callable中确定执行的任务
        //在FutureTask装置中完成任务加载——卢本伟准备就绪~~~
        //最后引入线程——卢本伟启动！！
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t1 = new Thread(futureTask);
        t1.start();
        t1.join();
        System.out.println(futureTask.get());//装置获得一下结果
    }
}

f9ffe1814187431eaf22c06ab0cba29c.png

补充一点：.futureTask.get()方法本身自带阻塞特性，如果Callable任务还没有执行完，是会一直等待它的返回值结果的

二：ReentrantLock——可重入锁

读音：“瑞安纯特老科” 翻译为：可重入锁

科普：ReentrantLock在很早以前是比没有发展起来的synchronized功能更加强大的，他提供了两个传统的方法lock和unlock，但是在写代码的过程中lock完后往往会忘记unlock解锁，所以一般把unlock操作放到finally里面使用

1：与synchronized的区别

（1）不会阻塞

我们知道synchronized加锁，如果线程“锁竞争”失败，会陷入阻塞等待，使用了ReentrantLodk提供了trylock方法后，如果加不上锁就会返回false，不会阻塞等待。

（2）公平锁

ReentrantLock中加锁依据是：公平锁，所有参与“加锁”的线程会被放进队列里面，按顺序进行加锁。

（3）唤醒机制不同

synchronized提供wait和notify，ReentrantLock搭配Condition，功能比notify强一点

三：Semaphore——信号量

读音：“赛摸佛尔” 翻译为：信号量

科普：因为发明信号量的大佬迪杰斯特拉是个荷兰人，荷兰语的申请和释放首字母分别是P和V。实际上英语是acquire和release

1：P操作

申请一个可用资源，可用资源总数就会-1

2：V操作

释放一个可用资源，可用资源总数就会+1

打个比方：去停车场停车，现在有50个停车位，申请一个停车位（p操作），现有可用停车位为49；出来了一辆车（v操作），现有可用停车位为50；

3：PV代码示例一

package thread;

import java.util.concurrent.Semaphore;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-30
 * Time: 10:26
 */
public class ThreadDemon39 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(1);//资源数限制为1个
        semaphore.acquire();
        System.out.println("p操作");
        semaphore.acquire();//第二次申请
        System.out.println("p操作");
        semaphore.acquire();//第三次申请
        System.out.println("p操作");

    }
}

9cf9b627497042ea9426d8388842301a.png

4：锁功能

信号量是更为广义的锁

代码示例：继续沿用解决count计数器++线程安全问题的方式

package thread;

import java.util.concurrent.Semaphore;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-30
 * Time: 10:33
 */
public class ThreadDemon40 {
    private static int count = 0;
    //引入Semaphore进行加锁
    private static Semaphore semaphore = new Semaphore(1);
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                semaphore.acquire();//加锁
                for (int i = 1 ; i <= 50000 ; i++){
                    count++;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            semaphore.release();//解锁
        });
        Thread t2 = new Thread(() ->{
            try {
                semaphore.acquire();//加锁
                for (int i = 1 ; i <= 50000 ; i++){
                    count++;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            semaphore.release();//解锁
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

4f2381686367498d83b6d9736d662e7c.png

四：CountDownLatch

1：引入

latch(锁存器)

举个例子，现在下载软件的速度非常快，用的是多线程下载方式，比如要下载一个1G大小的软件，我们把这个任务分成10份，分给10个线程同时进行下载，最后在拼在一起，速度就会快非常多。

这个“拼”的操作，就能被CountDownLatch感知到，比我们用join要更简单方便一些

2：代码示例

package thread;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-30
 * Time: 10:57
 */
public class ThreadDemon41 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);//创建10个线程
        Random random = new Random();
        int time = (random.nextInt(4)+1)*1000;//time的范围[0,4]->[1,5]->[1000,5000]
        for(int i = 1 ; i <= 10 ; i++){
            int count = i;
            Thread t = new Thread(() ->{
                try {
                    Thread.sleep(random.nextInt(time));//产生的随机数的范围
                    System.out.println("第" + count + "线程的任务执行完毕");
                    latch.countDown();//告知CountDownLatch有一个任务已经执行完毕了
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
        latch.await();//如果CountDownLatch中的任务还没有执行完毕，那么CountDownLatch就会陷入阻塞等待
        System.out.println("所有任务都已经执行完毕了");
    }
}

ab344df1b057467297751a6554e614ea.png


http://www.kler.cn/news/327685.html

相关文章：

  • spring boot集成日志
  • Hadoop集群的高可用（HA）：NameNode和resourcemanager高可用的搭建
  • tauri中加载本地文件图片或者下载网络文件图片后存储到本地，然后通过前端页面展示
  • Trilium Notes笔记本地化部署与简单使用指南打造个人知识库
  • 数据结构和算法基础（一）
  • 探索Cherry键盘的FN+F9游戏模式与Ctrl+Fn功能
  • ffmpeg 结合 opencv 显示ps流文件
  • 深入计算机语言之C++：C到C++的过度
  • set和map结构的使用
  • Spring Boot技术在足球青训管理中的实践与挑战
  • STM32的DMA技术介绍
  • failed to load steamui.dll的多种处理方法，steamui.dll的作用
  • 论文阅读 | HiDDeN网络架构
  • 【规控+slam】探索建图方案及代码分享
  • 基于Springboot+Vue的农场投入品运营线上管理系统 （含源码数据库）
  • Python学习（3）：画散点图和箱线图
  • 助农小程序|助农扶贫系统|基于java的助农扶贫系统小程序设计与实现(源码+数据库+文档)
  • 大数据-156 Apache Druid 案例实战 Scala Kafka 订单统计
  • 2024年7月大众点评宁波美食店铺基础信息
  • Oracle控制文件全部丢失如何使用RMAN智能恢复？
  • uniapp 通过标签生成海报
  • 在MacOS上安装MongoDB数据库
  • 随记——机器学习
  • Google常用插件-Vimium 键盘打通关
  • MMD模型及动作一键完美导入UE5-衣服布料模拟（四）
  • Springboot 练习
  • 第七届蓝桥杯嵌入式省赛程序设计题解析（基于HAL库）
  • ubuntu 24.04如何分配内存
  • 前端知识汇总（持续更新）
  • Flask-SQLAlchemy：在Flask应用中优雅地操作数据库