JUC并发编程（JUC核心类、TimeUnit类、原子操作类、CASAQS）附带相关面试题

目录

1.JUC并发编程的核心类

2.TimeUnit（时间单元）

3.原子操作类

4.CAS 、AQS机制

1.JUC并发编程的核心类

虽然java中的多线程有效的提升了程序的效率，但是也引发了一系列可能发生的问题，比如死锁，公平性、资源管理以及如何面对线程安全性带来的诸多危害。为此，java就提供了一个专门的并发编程包java.util.concurrent（简称JUC）。此包能够有效的减少了竞争条件和死锁问题。

以下介绍JUC包中核心的类

类名描述
ExecutorExecutor 是一个接口，定义了一种执行任务的方式，其目的是将任务的提交与任务的执行解耦。
ExecutorServiceExecutorService 是 Executor 的子接口，提供了更丰富的功能，例如线程池管理和任务提交等。
ScheduledExecutorServiceScheduledExecutorService 是 ExecutorService 的子接口，可以按照计划（时间或延迟）来执行任务。
CompletionServiceCompletionService 是一个用于异步执行任务并获取已完成任务结果的框架。
CallableCallable 是一个代表可以返回结果或抛出异常的任务的接口。它类似于 Runnable 接口，但具有返回值。
FutureFuture 是一个可用于获取异步计算结果的接口。
ReentrantLockReentrantLock 是一个可重入锁，它提供了更灵活的同步控制和更高级别的功能。
BlockingQueueBlockingQueue 是一个支持阻塞操作的队列，提供了线程安全的生产者-消费者模式的实现。
CountDownLatchCountDownLatch 是一个同步辅助类，允许一个或多个线程等待其他线程完成操作后再继续执行。
CyclicBarrierCyclicBarrier 是一个同步辅助类，使得一组线程能够互相等待，直到所有线程都达到某个公共屏障点。

2.TimeUnit（时间单元）

这个类能够非常好的让我们实现各种时间之间的转换。TimeUnit类的是枚举类，里面有DAYS（天）,HOURS（小时）,MINUTES（分钟）,SECONDS（秒）,MILLISECONDS（毫秒）,NANNOSECONDS（纳秒）

TimeUnit类中常用的方法：

方法签名描述
public long convert(long sourceDuration, long srcDuration)该方法用于将给定的时间源持续时间转换为目标持续时间。
public void sleep(long timeout) throws InterruptedException该方法使当前线程进入休眠状态，暂停执行一段指定的时间（以毫秒为单位）。如果在休眠期间中断了线程，则会抛出 InterruptedException 异常。

具体应用案例：

1.时间转换与输出一个月后的日期

package Example2101;import java.util.Date;
import java.util.concurrent.TimeUnit;public class javaDemo {public static void main(String[] args) {
//        五个小时时间long hours = 5;
//        通过SECONDS类将5个小时转为秒long seconds = TimeUnit.SECONDS.convert(hours,TimeUnit.HOURS);System.out.println(seconds);//        获取当前时间long now = System.currentTimeMillis();long furture = now + TimeUnit.MILLISECONDS.convert(30,TimeUnit.DAYS);System.out.println("Now Time is"+new Date(now));Date futureDay = new Date(furture);System.out.println("after mounth time is"+futureDay);}
}

 

案例2：定义一个闹钟，这个闹钟在5天后会自动发送消息

这种闹钟形式可以通过线程的睡眠机制进行完成，但是一般情况下如果使用线程的睡眠Thread.sleep()里面放的是毫秒，如果要睡眠五天，那么需要设置的数值会非常非常大的，所以可以使用TimeUnit类的睡眠方法实现自定义睡眠。

package Example2102;import java.util.concurrent.TimeUnit;public class javaDemo {public static void main(String[] args) {new Thread(()->{try {
//                通过TimeUnit下的Days类的sleep函数定义五天时间TimeUnit.DAYS.sleep(5);System.out.println("闹钟响了！！！！！！");}catch (InterruptedException e){e.printStackTrace();}},"闹钟").start();}
}

3.原子操作类

问题引出：一般情况下如果多线程进行竞争一个变量时候会引发数据错乱的问题。比如多线程下售票员售票案例，由于多个线程竞争，一张票可能已经被卖出去了，但是其他的售票员并不知道，继续售卖同一张票。在之前的时候我们通过了Sychronized（）同步位解决了这个问题。但是用这个方法也有不小的弊端，那就是程序效率会大大下降。为此JUC提供了一个新的方式解决这个问题，那就是原子操作类。

首先理解原子性，原子是不可分割的最小物体，在编程中是指一种操作要么做了，要么不做。不可以中断的一种操作。原子操作类具有更高效率，更安全，更简单用法

原子操作类分为很多类，大致分为4类：

基本类型：AtomicInteger 、AtomicLong、AtomicBoolean

数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

引用类型：AtomicReference、AtomicStampedReference、AtomicMarkableReference；

对象属性修改类型：

AtomicIntegerFieldUpdater；AtomicLongFiledUpdater；AtomicReferenceFieldUpdater；

 1.基本类型的原子操作类

基本类型：AtomicInteger 、AtomicLong、AtomicBoolean

基本类型之间的操作是差不多的，这里用AtomicLong举例

AtomicLong的常用方法

方法描述
AtomicLong(long initValue)创建一个新的AtomicLong实例，并设置初始值为initValue。
get()获取当前存储在AtomicLong中的值。
set(long newValue)将AtomicLong的值设置为newValue。
getAndIncrement()先获取当前存储在AtomicLong中的值，然后将AtomicLong的值增加1。返回先前的值。
setAndIncrement()将AtomicLong的值增加1。返回增加前的值。
decrementAndGet()将AtomicLong的值减少1，并返回减少后的值。

使用类方法的关键就在于熟悉add（增加） decrement（自减）increment(自增) set（设置值） get（获取类内部的数据） 方法就是这几个操作之间的组合

案例代码：多个售票员售卖100张票

package Example2103;import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;public class javaDemo {public static void main(String[] args) {
//        创建原子操作类AtomicInteger ticket = new AtomicInteger(6);AtomicInteger flag = new AtomicInteger(1);//标志还有票//        创建三个线程进行售票for (int i =0;i<3;i++){new Thread(()->{while (ticket.get()>0){System.out.println("售票员"+Thread.currentThread().getName()+"售卖第"+ticket.decrementAndGet()+"张票");try {
//                        设置两秒睡眠TimeUnit.SECONDS.sleep(2);}catch (Exception e){e.printStackTrace();}
//                    如果没有票了就将标志位的值设置为0，表示没有票了if (ticket.get() == 0){flag.set(0);System.out.println("卖完了");}}}).start();}}
}

 

 可以看到即使没有使用同步机制也实现了同步的效果。

2.数组原子操作类

数组原子操作类有：AtomicArrayInteger AtomicLongArray AtomicReferenceArray（对象数组）

由于三者这件的使用区别不大，所以这里展示AtomicReferenceArray

AtomicReferenceArray常用方法：

方法描述
AtomicReferenceArray(int length)构造一个指定长度的AtomicReferenceArray对象。
AtomicReferenceArray(E[] array)使用给定数组初始化AtomicReferenceArray对象。
int length()返回AtomicReferenceArray的长度（即元素个数）。
boolean compareAndSet(int index, E expect, E update)将指定索引位置的元素与期望值进行比较，如果相等，则将其更新为新的值。该操作是原子性的，返回是否更新成功。
E get(int index)获取指定索引位置的元素的值。
void set(int index, E newValue)设置指定索引位置的元素的值为newValue。
E getAndSet(int index, E newValue)获取指定索引位置的元素的当前值，并将其设置为newValue。

 案例代码：

package Example2104;import java.util.concurrent.atomic.AtomicReferenceArray;public class javaDemo {public static void main(String[] args) {String data[] = new String[]{"王二狗","180","130"};
//        初始化AtomicReferenceArray<String> array = new AtomicReferenceArray<String>(data);
//        对象数组的操作System.out.println("身高是:"+array.get(1));array.set(2,"150");System.out.println(array.get(0)+"在拼命锻炼后体重变成:"+array.get(2));
//        筛选如果名字是王二狗的自动改名王二array.compareAndSet(0,"王二狗","王二");System.out.println("改名后名字叫"+array.get(0));}
}

 3.引用原子操作类

引用类型：AtomicReference、AtomicStampedReference、AtomicMarkableReference；

其中AtomicReference是可以直接引用数据类型的原子性操作

下面是AtomicReference的常用方法：

方法描述
AtomicReference()无参构造方法，创建一个初始值为null的AtomicReference对象。
V get()获取当前AtomicReference对象持有的值。
void set(V newValue)设置AtomicReference对象的值为newValue。
boolean compareAndSet(V expect, V update)将AtomicReference对象的值与期望值expect进行比较（==比较），如果相等，则将其更新为新值update。该操作是原子性的，返回是否更新成功。
V getAndSet(V newValue)先获取当前AtomicReference对象的值，然后将其设置为newValue，并返回原来的值。

案例代码：使用AtomicReference进行引用操作

package Example2106;import java.util.concurrent.atomic.AtomicReference;
// 创建普通人类
class Person{private int age;private String name;private int id;Person(int age,String name,int id){this.age = age;this.name = name;this.id = id;}
}public class javaDemo {public static void main(String[] args) {Person person1 = new Person(18,"张三",001);Person person2 = new Person(20,"王思",1002);
//        传入person1对象AtomicReference<Person> person = new AtomicReference<Person>(person1);
//        输出对象地址System.out.println(person.get());
//        更改引用对象person.set(person2);System.out.println(person.get());}
}

AtomicStampedReference 基于版本号的数据引用。其中版本号是自己定义的int数据类型

下面是AtomicStampedReference的常用方法：

方法描述
AtomicStampedReference(V initRef, int initStamp)构造一个AtomicStampedReference对象，初始引用值为initRef，初始标记值（戳）为initStamp。
V getReference()获取当前AtomicStampedReference对象持有的引用值。
void set(V newRef, int newStamp)设置AtomicStampedReference对象的引用值为newRef，标记值（戳）为newStamp。
boolean compareAndSet(V expectRef, V newRef, int expectStamp, int newStamp)将AtomicStampedReference对象的引用值与期望值expectRef、标记值（戳）与期望值expectStamp进行比较，如果相等，则将其更新为新值newRef和newStamp。该操作是原子性的，返回是否更新成功。
int attemptStamp(V expectedReference, int newStamp)如果当前引用值等于expectedReference，则尝试将标记值（戳）更新为newStamp。如果更新成功，返回新的标记值（戳），否则返回当前标记值。
int getStamp()获取当前AtomicStampedReference对象持有的标记值（戳）。

案例代码：

package Example2107;import java.util.concurrent.atomic.AtomicStampedReference;class Draw{private String content = "";private String autor = "";private String title ="";Draw(String content,String autor,String title){this.content =content;this.autor = autor;this.title = title;}public void setContent(String content) {this.content = content;}public String getContent() {return content;}
}
public class javaDemo {public static void main(String[] args) {Draw  draw1= new Draw("","alphaMilk","JUC并发编程原子操作类");
//        初始化内容，版本号为1AtomicStampedReference<Draw> atomicDraw = new AtomicStampedReference<Draw>(draw1,1);System.out.println(atomicDraw.getReference());
//        更新内容，版本号更改draw1.setContent("Hello,word");atomicDraw.set(draw1,2);
//        获取当前版本System.out.println(atomicDraw.getStamp());}
}

AtomicMarkableReference与AtomicStampedReference的区别在于，一个是设置boolean类型的初始化标记，一个多设置的是int类型版本号

下面是AtomicMarkableReference的常用方法：

方法描述
AtomicMarkableReference(V initRef, boolean initMark)构造一个AtomicMarkableReference对象，初始引用值为initRef，初始标记值为initMark。
V getReference()获取当前AtomicMarkableReference对象持有的引用值。
boolean isMarked()判断当前AtomicMarkableReference对象是否被标记。
boolean compareAndSet(V expectRef, V newRef, boolean expectMark, boolean newMark)将AtomicMarkableReference对象的引用值与期望值expectRef、标记值与期望值expectMark进行比较，如果相等，则将其更新为新值newRef和newMark。该操作是原子性的，返回是否更新成功。
void set(V newRef, boolean newMark)设置AtomicMarkableReference对象的引用值为newRef，标记值为newMark。
boolean attemptMark(V expectedReference, boolean newMark)如果当前引用值等于expectedReference，则尝试将标记值更新为newMark。如果更新成功，返回true，否则返回false。

案例代码：

一个班统计同学是否交了班费

package Example2108;import java.util.concurrent.atomic.AtomicMarkableReference;class  Student{private String name;private int id;Student(String name,int id){this.name = name;this.id = id;}
}
public class javaDemo {public static void main(String[] args) {Student stu1 = new Student("王一",001);Student stu2 = new Student("张二蛋",002);
//        王一交过班费AtomicMarkableReference<Student> atoStu = new AtomicMarkableReference<Student>(stu1,true);System.out.println(atoStu.getReference());if (atoStu.isMarked()){System.out.println("该同学交过班费");}else System.out.println("该同学尚未交过班费");
//        张二蛋没有交班费atoStu.set(stu2,false);System.out.println(atoStu.getReference());if (atoStu.isMarked()){System.out.println("该同学交过班费");}else System.out.println("该同学尚未交过班费");}
}

4.对象属性修改原子类

 AtomicIntegerFieldUpdater；AtomicLongFiledUpdater；AtomicReferenceFieldUpdater；

这三个类的实现原理基本差不多，所以将用AtomicIntegerFieldUpdater举例：

以下是AtomicIntegerFieldUpdater类的常用方法：

int addAndGet(T obj, int data)将指定对象obj的字段值与data相加，并返回相加后的结果。
boolean compareAndSet(T obj, int expect, int update)将指定对象obj的字段值与期望值expect进行比较，如果相等，则将其更新为新值update。返回是否更新成功。
int get(T obj)获取指定对象obj的字段值。
int getAndSet(T obj, int newValue)获取指定对象obj的字段值，并将其设置为新值newValue。
int decrementAndGet(T obj)将指定对象obj的字段值减1，并返回减1后的结果。
int incrementAndGet(T obj)将指定对象obj的字段值加1，并返回加1后的结果。

 案例代码：

package Example2109;import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;class Book{volatile long id;volatile String name;Book(long id, String name){this.id = id;this.name = name;}}public class javaDemo {public static void main(String[] args) {Book book1 = new Book(114514,"Java从入门到入土");AtomicReferenceFieldUpdater<Book,String> bookmanger = AtomicReferenceFieldUpdater.newUpdater(Book.class,String.class,"name");System.out.println("更新前书本名称为:"+bookmanger.get(book1));bookmanger.set(book1,"Java从入门到项目实战");System.out.println("更新后书本名称为:"+bookmanger.get(book1));}
}

 

4.CAS 、AQS机制

CAS是一条CPU并发原语。它的功能是判断某个内存某个位置的值是否相等，如果是则改为新的值，这个操作过程属于原子性操作。

CAS是乐观锁，是一种冲突重试机制，在并发竞争不是很剧烈的情况下，其操作性能会好于悲观锁机制（Synchronization同步处理）

*面试题为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？

  1. Synchronized的并发策略是悲观的，不管是否产生竞争，任何数据的操作都必须加锁。
  2. 乐观锁的核心是CAS，CAS包括内存值、预期值、新值，只有当内存值等于预期值时，才会将内存值修改为新值。

*面试题：乐观锁一定就是好的吗？

  1. 乐观锁认为对一个对象的操作不会引发冲突，所以每次操作都不进行加锁，只是在最后提交更改时验证是否发生冲突，如果冲突则再试一遍，直至成功为止，这个尝试的过程称为自旋。
  2. 乐观锁没有加锁，但乐观锁引入了ABA问题，此时一般采用版本号进行控制；
  3. 也可能产生自旋次数过多问题，此时并不能提高效率，反而不如直接加锁的效率高；
  4. 只能保证一个对象的原子性，可以封装成对象，再进行CAS操作；

*面试题：volatile 关键字的作用

对于可见性，Java 提供了 volatile 关键字来保证可见性和禁止指令重排。 volatile 提供 happens-before 的保证，确保一个线程的修改能对其他线程是可见的。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

从实践角度而言，volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。

volatile 常用于多线程环境下的单次操作(单次读或者单次写)。
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/59398.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

python基础3——流程控制

python基础3——流程控制

文章目录 一、操作符1.1 比较操作符1.2 逻辑操作符1.3 成员操作符1.4 身份操作符 二、流程控制2.1 条件判断2.2 循环语句2.2.1 for循环2.2.2 while循环 2.3 continue与break语句2.4 文件操作函数 三、函数3.1 定义函数3.2 作用域3.3 闭包3.4 函数装饰器3.5 内建函数 一、操作符…
阅读更多...
vuejs 设计与实现 - 渲染器的设计

vuejs 设计与实现 - 渲染器的设计

渲染器与响应式系统的结合 本节&#xff0c;我们暂时将渲染器限定在 DOM 平台。既然渲染器用来渲染真实 DOM 元素&#xff0c;那么严格来说&#xff0c;下面的函数就是一个合格的渲染器: // 渲染器&#xff1a; function renderer(domString, container) {container.innerHTM…
阅读更多...
新能源汽车交流充电桩控制主板的功能维度

新能源汽车交流充电桩控制主板的功能维度

新能源汽车交流充电桩控制主板的功能维度 交流充电桩主板是电动汽车充电站的关键组件&#xff0c;它负责控制充电过程&#xff0c;保护设备和电网免受电动汽车充电的冲击。它具有控制、保护、检测、报警和记录等功能&#xff0c;可以有效地控制充电过程&#xff0c;保证交流充电…
阅读更多...
K8s集群安全机制

K8s集群安全机制

1.访问K8s集群的时候&#xff0c;需要经过三个步骤完成具体操作 &#xff08;1&#xff09;认证&#xff08;2&#xff09;鉴权&#xff08;授权&#xff09;&#xff08;3&#xff09;准入控制 进行访问的时候&#xff0c;过程中都要经过apiserver&#xff0c;apiserver做统…
阅读更多...
JDK, JRE和JVM之间的区别和联系

JDK, JRE和JVM之间的区别和联系

JDK, JRE和JVM是与Java编程语言相关的三个重要的概念&#xff0c;它们分别代表Java Development Kit&#xff08;Java开发工具包&#xff09;、Java Runtime Environment&#xff08;Java运行时环境&#xff09;和Java虚拟机&#xff08;Java Virtual Machine&#xff09;。它们…
阅读更多...
深入探究Spring核心模块

深入探究Spring核心模块

&#x1f337;&#x1f341; 博主猫头虎 带您 Go to New World.✨&#x1f341; &#x1f984; 博客首页——猫头虎的博客&#x1f390; &#x1f433;《面试题大全专栏》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33a; &a…
阅读更多...
ASL国产CS5213 转VGA信号输出音频 替代AG6200安格芯片 HDMI to VGA（带音频）方案设计原理图

ASL国产CS5213 转VGA信号输出音频 替代AG6200安格芯片 HDMI to VGA（带音频）方案设计原理图

CS5213功能&#xff1a;HDMI转VGA带音频输出&#xff0c;专注于设计HDMI转VGA带音频输出。可替代AG6200 AG6201。 CS5213芯片是一个HDMI&#xff08;高清多媒体接口&#xff09;到VGA桥接芯片。 它将HDMI信号转换为标准VGA信号它可以在适配器、智能电缆等设备中设计。 Capst…
阅读更多...
【Git】保姆级详解：Git配置SSH Key（密钥和公钥）到github

【Git】保姆级详解：Git配置SSH Key（密钥和公钥）到github

博主简介&#xff1a;22级计算机科学与技术本科生一枚&#x1f338;博主主页&#xff1a;是瑶瑶子啦每日一言&#x1f33c;: “当人们做不到一些事情的时候&#xff0c;他们会对你说你也同样不能。”——《当幸福来敲门》 克里斯加德纳 Git配置SSH Key 一、什么是Git?二、什么…
阅读更多...
MapTR论文笔记

MapTR论文笔记

MAPTR: STRUCTURED MODELING AND LEARNING FOR ONLINE VECTORIZED HD MAP CONSTRUCTION 目的 传统高精地图 通过一些离线的基于 SLAM 的方法生成&#xff0c;需要复杂的流程以及高昂的维护费用。基于 bev 分割的建图方法&#xff0c;缺少向量化 实例级的信息&#xff0c;比如…
阅读更多...
python制作小程序制作流程,用python编写一个小程序

python制作小程序制作流程,用python编写一个小程序

这篇文章主要介绍了python制作小程序代码宠物运输&#xff0c;具有一定借鉴价值&#xff0c;需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获&#xff0c;下面让小编带着大家一起了解一下。 1 importtkinter2 importtkinter.messagebox3 importmath4 classJSQ:5 6 7 d…
阅读更多...
深入浅出对话系统——闲聊对话系统进阶

深入浅出对话系统——闲聊对话系统进阶

引言 本文主要关注生成式闲聊对话系统的进阶技术。 基于Transformer的对话生成模型 本节主要介绍GPT系列文章&#xff0c;这是由OpenAI团队推出的&#xff0c;现在大火的ChatGPT也是它们推出的。 GPT : Improving Language Understanding by Generative Pre-Traini ng 在自…
阅读更多...
基于Java的新闻全文搜索引擎的设计与实现

基于Java的新闻全文搜索引擎的设计与实现

中文摘要 本文以学术研究为目的&#xff0c;针对新闻行业迫切需求和全文搜索引擎技术的优越性&#xff0c;设计并实现了一个针对新闻领域的全文搜索引擎。该搜索引擎通过Scrapy网络爬虫工具获取新闻页面&#xff0c;将新闻内容存储在分布式存储系统HBase中&#xff0c;并利用倒…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023