【Java多线程】面试常考 —— JUC(java.util.concurrent) 的常见类

简介: 【Java多线程】面试常考 —— JUC(java.util.concurrent) 的常见类

1、JUC(java.util.concurrent)

这是java中的一个包,存放着多线程编程中常见的一些类。


1.1、Callable 接口


有如下几种:


1、继承 Thread(包含了匿名内部类的方式)


2、实现 Runnable(包含了匿名内部类的方式)


3、基于 lambda 表达式


其实除了以上方式,还有一个方式可以创建线程,即基于 Callable 的创建方法。


 

public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<>() {
            @Override
            public Integer call() throws Exception {
                int ret = 0;
                for (int i = 1; i <= 1000; i++) {
                    ret += i;
                }
                return ret;
            }
        };
        //引入 FutureTask 类,作为 Thread 和 callable 的 “粘合剂”
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        //取餐号,使用 futureTask 获取到结果,具有阻塞功能
        System.out.println(futureTask.get());
    }

基于 Callable 同样可以创建线程,那么它与 Runnable 有什么区别呢?


Runnable 关注的是整个过程,不关注执行结果,Runnable 提供的是 run 方法,返回值类型是 void。

Callable 关注的是执行结果,Callable 提供的是 call 方法,返回值就是线程执行任务得到的结果。

因此,如果编写多线程代码时,希望关注线程中代码的返回值时,此时使用基于 Callable 实现的线程更为方便。


1.2、ReentrantLock 可重入锁

与 synchronized 有区别,上古时期的 Java,synchronized 还不够强壮,功能也不够强大,也没有各种优化,当时 ReenactmentLock 就是实现可重入锁的选择。


ReenactmentLock 的用法具有传统锁的风格,上锁使用lock(),解锁使用unlock()。

由于需要手动解锁,触发 return 或者 异常时 容易忘记解锁,为了避免这种问题,正确使用 ReenactmentLock 时需要把 unlock 操作放到 finally 中。


问题:既然有 synchronized,为啥还要用 ReenactmentLock ?(面试题)


1、ReenactmentLock 提供了 tryLock 操作。


lock 尝试进行加锁,如果加锁不成,就会阻塞;

tryLock 尝试进行加锁,如果加锁不成,不阻塞,直接返回 false;(更多的可操作空间)

2、ReenactmentLock 提供了公平锁的实现,通过队列记录加锁线程的先后顺序。


3、搭配的等待通知机制不同。


对于 synchronized,搭配 wait/notify

对于 ReenactmentLock,搭配 Condition 类,功能比 wait/notify 略强一些

1.3、Semaphore 信号量

首先举例说明 semaphore 信息量的概念:停车场入口立着的那个显示屏,每有一辆车进入停车场显示屏就会显示剩余车位减1,每有一辆车从停车场出去,显示屏上显示的剩余车辆就会加1,当显示屏上的剩余车位为0时,停车场入口的栏杆就不会再打开,车辆就无法进入停车场了,直到有一辆车从停车场出去为止。


而这个场景中提及的“显示屏”这个东西,就可以认为是信息量,表示“可用资源的个数”,申请一个可用资源,就会使数字 - 1,这个操作就成为 p 操作,释放一个可用资源,就会使数字 + 1,这个操作就是 v 操作,如果信息量数值为 0,继续 p 操作就会进行阻塞。


信号量是更广义的“锁”。所谓锁,本质上也是一种特殊的信息量,可以把锁认为是计数值为 1 的信息量。释放状态,就是1,加锁状态就是0,对于这种非0即1的信息量,称为“二元信息量”。除此之外,同样 Semaphore 也可以用来实现生产者消费者模型。


acquire() 表示申请资源(P操作);

release() 表示释放资源(V操作);


使用 semaphore 模式锁并使用模拟锁实现两个线程同时对 i 自增 5w 的操作


package thread;
import java.util.concurrent.Semaphore;
public class ThreadDemo38 {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        //信息量设置为 1
        Semaphore semaphore = new Semaphore(1);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = " + count);
    }
}


1.4、CountDownLatch

针对特定场景下解决问题的小工具。作用:同时等待 N 个任务执行结束。


比如,多线程执行一个任务,把大的任务拆分成几个部分,由每个线程分别执行。“多线程下载”:idm,比特彗星。


package thread;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
public class ThreadDemo39 {
    public static void main(String[] args) throws InterruptedException {
        // 1. 此处构造方法中写 10, 意思是有 10 个线程/任务
        CountDownLatch latch = new CountDownLatch(10);
        // 创建出 10 个线程负责下载.
        for (int i = 0; i < 10; i++) {
            int id = i;
            Thread t = new Thread(() -> {
                Random random = new Random();
                // [0, 5)
                int time = (random.nextInt(5) + 1) * 1000;
                System.out.println("线程 " + id + " 开始下载");
                try {
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程 " + id + " 结束下载");
                // 2. 告知 countDownLatch 我执行结束了.
                latch.countDown();
            });
            t.start();
        }
        // 3. 通过这个 await 操作来【等待所有任务结束】. 也就是 countDown 被调用 10 次了.
        latch.await();
        System.out.println("所有任务都已经完成了!");
    }
}


每个任务执行完毕,都调用 latch.countDown()。在 CountDownLatch 内部的计数器同时自减。

主线程中使用 latch.await(); 阻塞等待所有任务执行完毕,相当于计数器为 0 了。


目录
相关文章
|
14天前
|
JSON 网络协议 安全
【Java】(10)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
64 1
|
14天前
|
JSON 网络协议 安全
【Java基础】(1)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
57 1
|
15天前
|
缓存 安全 Java
JUC系列《深入浅出Java并发容器:CopyOnWriteArrayList全解析》
CopyOnWriteArrayList是Java中基于“写时复制”实现的线程安全List,读操作无锁、性能高,适合读多写少场景,如配置管理、事件监听器等,但频繁写入时因复制开销大需谨慎使用。
|
15天前
|
设计模式 算法 安全
JUC系列之《深入理解AQS:Java并发锁的基石与灵魂 》
本文深入解析Java并发核心组件AQS(AbstractQueuedSynchronizer),从其设计动机、核心思想到源码实现,系统阐述了AQS如何通过state状态、CLH队列和模板方法模式构建通用同步框架,并结合独占与共享模式分析典型应用,最后通过自定义锁的实战案例,帮助读者掌握其原理与最佳实践。
|
前端开发 Java C++
JUC系列之《CompletableFuture:Java异步编程的终极武器》
本文深入解析Java 8引入的CompletableFuture,对比传统Future的局限,详解其非阻塞回调、链式编排、多任务组合及异常处理等核心功能,结合实战示例展示异步编程的最佳实践,助你构建高效、响应式的Java应用。
|
1月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
Java 数据库 Spring
89 0
|
3月前
|
数据采集 监控 调度
干货分享“用 多线程 爬取数据”:单线程 + 协程的效率反超 3 倍,这才是 Python 异步的正确打开方式
在 Python 爬虫中,多线程因 GIL 和切换开销效率低下,而协程通过用户态调度实现高并发,大幅提升爬取效率。本文详解协程原理、实战对比多线程性能,并提供最佳实践,助你掌握异步爬虫核心技术。
|
3月前
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
157 0
|
4月前
|
Java 数据挖掘 调度
Java 多线程创建零基础入门新手指南:从零开始全面学习多线程创建方法
本文从零基础角度出发,深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析,帮助读者理解每种方式的特点及适用场景,理论结合实践,轻松掌握Java多线程编程 essentials。
286 5