狂神说 JUC并发编程
文章目录
- 基本概念
-
- JUC
- 进程和线程
- 并发和并行
- 线程状态
- wait 和 sleep
- Synchronized 与Lock
- CopyOnWriteArrayList
- Callable
- 常用辅助类
- ReadWriteLock
- BlockingQueue
- 线程池
- 四大函数式接口
- 流式计算
- ForkJoin详解
- 异步回调
- JMM
- Volatile
- 禁止指令重排
- CAS
- 原子引用
- 自旋锁
基本概念
JUC
JUC指的是以下三个包：
进程和线程
- 一个进程可以包含多个线程，至少包含一个线程；Java默认有2个线程，main线程、GC线程
- Java是没有权限去开启线程、操作硬件的，Java多线程里执行start方法会调用一个native的本地方法，它调用的底层的C++代码
并发和并行
并发: 多线程操作同一个资源（并发编程—多个线程操作同一个资源类）, CPU 只有一核，可以使用CPU快速交替, 模拟出来多条线程
并行：CPU多核，多个线程可以同时执行
线程状态
6 种状态，详情参考
public enum State {
NEW, // 新创建了一个线程对象，但还没有调用start()方法
RUNNABLE, // Java线程中将就绪和运行两种状态笼统的称为“运行”
BLOCKED, // 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块时的状态
WAITING, // 处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态
TIMED_WAITING, // 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒
TERMINATED; // 当线程的run()方法完成时，或者主线程的main()方法完成时；出现一个没有捕获的异常，终止了 run() 方法，最终导致意外终止
}
wait 和 sleep
- wait 来自 Object类，sleep来自Thread类
- 企业中一般使用JUC包中的以下方法进行睡眠
TimeUnit.DAYS.sleep(1); //休眠一天
TimeUnit.SECONDS.sleep(1); //休眠1秒
- 锁的释放
wait 会释放锁，sleep不会释放锁
- 使用的范围
wait只能在同步代码块中使用，sleep可以在任何地方睡
- 是否需要捕获异常
wait不用捕获异常（需要捕获中断异常？？），sleep需要捕获异常
Synchronized 与Lock
- Synchronized 是内置的Java关键字，Lock是一个Java类
- Synchronized 无法判断获取锁的状态，Lock可以判断
- Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁
- Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。
- Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；
- Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；
CopyOnWriteArrayList
使用ArrayList，当多个线程同时写入数据时会产生
java.util.ConcurrentModificationException异常（并发修改异常）
package com.rainhey.juc;
import java.util.ArrayList;
import java.util.UUID;
public class Test1 {
public static void main(String[] args) throws InterruptedException {
ArrayList list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0, 5));
System.out.println(list);
}).start();
}
}
}
解决方案：
- 使用vector代替arrylist，
Listlist = new Vector<>(); - 使用collections工具类，
Listlist = Collections.synchronizedList(new ArrayList<>()); - CopyOnWrite，
List，写入复制list = new CopyOnWriteArrayList<>();
同理：并发访问set也会存在问题，解决方案也包括Set、Set
同理：并发访问map也会存在问题，解决方案 Map
Callable
1、可以有返回值；
2、可以抛出异常；
3、方法不同，call()
package com.rainhey.juc;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
mythread mythread = new mythread();
FutureTask futureTask = new FutureTask(mythread); // FutureTask 是Runnable的实现类，可以接受一个callable
new Thread(futureTask,"A").start();
new Thread(futureTask,"B").start();
String str = (String) futureTask.get(); // 返回callable的返回值，可能会产生阻塞
System.out.println(str);
}
}
class mythread implements Callable{
@Override
public String call() throws Exception {
System.out.println("call()");
return "hello";
}
}
细节：
1、有缓存
2、结果可能需要等待，会阻塞！
常用辅助类
减法计数器、加法计数器、信号量
CountDownLatch
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(6); // 设置初值
for (int i = 0; i < 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"go out");
countDownLatch.countDown(); //计数器减一
},String.valueOf(i)).start();
}
countDownLatch.await(); // 等待计数器归零后继续向下执行
System.out.println("close door");
}
}
CyclickBarrier
package com.rainhey.juc;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarriertest {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
System.out.println("召唤神龙！"); // 当有7个cyclicbarrier.await后就会第二个参数中的线程
});
for (int i = 0; i < 7; i++) {
final int temp=i; // lambda表达式可以捕获外围作用域中变量的值，且lambda表达式中只能引用值不会改变的变量，这个变量在表达式里面和表达式外面都不能改变
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集第"+temp+"颗龙珠");
try {
cyclicBarrier.await(); //等待
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
Semaphore
package com.rainhey.juc;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreTest {
public static void main(String[] args) {
// 资源个数，停车位
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 6; i++) {
new Thread(()->{
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"--->抢到车位！");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"离开车位！--->");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
}).start();
}
}
}
原理：semaphore.acquire()，获得，假设如果已经满了就等待，等待被释放为止；semaphore.release()，释放，会将当前的信号量释放 ，然后唤醒等待的线程！
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！
ReadWriteLock
package com.rainhey.juc;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 0; i < 20; i++) {
final int temp=i;
new Thread(()->{
myCache.write(String.valueOf(temp), String.valueOf(temp));
}).start();
}
for (int i = 0; i < 20; i++) {
final int temp=i;
new Thread(()->{
myCache.read(String.valueOf(temp));
}).start();
}
}
}
class MyCache{
private volatile Map map=new HashMap<>();
private ReadWriteLock lock=new ReentrantReadWriteLock();
public void write(String key,Object value){
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"线程开始写入");
map.put(key, value);
System.out.println(Thread.currentThread().getName()+"写入OK");
}finally {
lock.writeLock().unlock();
}
}
public void read(String key){
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"线程开始读取");
map.get(key);
System.out.println(Thread.currentThread().getName()+"读取OK");
}finally {
lock.readLock().unlock();
}
}
}
BlockingQueue
BlockingQueue四组API
| 方式 | 抛出异常 | 不会抛出异常，有返回值 | 阻塞，等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add | offer | put | offer(timenum.timeUnit) |
| 移除 | remove | poll | take | poll(timenum,timeUnit) |
| 判断队首元素 | element | peek | – | – |
SynchronousQueue：同步队列 没有容量，但可以视为容量为1的队列、put方法 和 take方法
线程池
重点掌握： 三大方法、7大参数、4种拒绝策略
程序的运行会占用系统的资源！我们需要去优化资源的使用 ===> 池化技术
池化技术包括：线程池、JDBC的连接池、内存池、对象池等
资源的创建、销毁十分消耗资源
池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后再归还，以此来提高效率
线程池的好处：降低资源的消耗；提高响应的速度；方便管理；
线程复用、可以控制最大并发数、管理线程；
三大方法
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的
package com.rainhey.juc;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
public static void main(String[] args) {
ExecutorService threadPool=Executors.newSingleThreadExecutor(); //单个线程
//ExecutorService threadPool=Executors.newFixedThreadPool(3); //创建固定线程池大小
//ExecutorService threadPool=Executors.newCachedThreadPool(); //可伸缩的，遇强则强，遇弱则弱
try {
for (int i = 0; i < 6; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" OK");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
threadPool.shutdown();
}
}
}
单个线程，循环6次
固定大小线程池，循环6次
可伸缩，循环20次
七大参数
以上三个方法本质上都是调用 ThreadPoolExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
}
----------------------------------------------------------
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
----------------------------------------------------------
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
}
阿里巴巴开发者手册中有如下规范：
由于工具类提供的三种创建线程池的方法存在一些缺陷，建议手动创建线程池
package com.rainhey.juc;
import java.util.concurrent.*;
public class MyThreadPool {
public static void main(String[] args) {
/*自定义线程池*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, // 核心线程池大小，永远准备开着的
5, // 最大线程池大小，当阻塞队列也满了则会触发核心线程以外的线程
3, // 超过3处于空闲则关闭线程窗口
TimeUnit.SECONDS, // 3的单位
new LinkedBlockingQueue(3), //阻塞队列
Executors.defaultThreadFactory(), // 线程工程，一般不用改
new ThreadPoolExecutor.AbortPolicy() //拒绝策略，4种
/**
* new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！，比如丢给main线程处理当前线程的任务
* new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
* new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常！
*/
);
try {
for (int i = 0; i < 8; i++) {
threadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" OK");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
threadPoolExecutor.shutdown();
}
}
}
七大参数的理解：
设置线程池大小
CPU密集型：电脑的核数是几核就选择几；选择maximunPoolSize的大小
I/O密集型：I/O密集型就是程序中有很多十分耗I/O的线程，线程池大小大约是最大I/O数的一倍到两倍之间
四大函数式接口
新时代的程序员必会：Lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口
- Function 函数型接口
- Predicate 断定型接口
- Consumer 消费型接口
- Suppier 供给型接口
流式计算
集合、MySQL 本质就是存储东西的；计算都应该交给流来操作！
package com.rainhey.juc;
import java.util.Arrays;
import java.util.List;
public class StreamTest {
public static void main(String[] args) {
/**
* 题目要求：一分钟内完成此题，只能用一行代码实现！
* 现在有5个用户！筛选：
* 1、ID 必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户！
*/
User u1 = new User(1, "a", 21);
User u2 = new User(2, "b", 22);
User u3 = new User(3, "c", 23);
User u4 = new User(4, "d", 24);
User u5 = new User(6, "e", 25);
List users = Arrays.asList(u1, u2, u3, u4);
users.stream()
.filter(user->{return user.getId()%2==0;})
.filter(user -> {return user.getAge()>23;})
.map(user->{return user.getName().toUpperCase();})
.sorted((user1,user2)->{return user1.compareTo(user2);})
.limit(1)
.forEach(System.out::println);
}
}
ForkJoin详解
ForkJoin 工作特点：工作窃取！
原理是双端队列！从上面和下面都可以去进行执行！，当B线程完成后，B线程回去执行A线程未完成的任务，提高效率
使用ForkJoin
- 通过ForkJoinPool 来执行任务，可以调用其submit方法
- 创建一个ForkJoinTask，继承其子类 RecursiveTask并重写 compute 方法；其中RecursiveAction是递归事件没有返回值，RecursiveTask是递归任务有返回值
package com.rainhey.juc;
import java.util.concurrent.RecursiveTask;
public class ForkJoinTask extends RecursiveTask {
private long star;
private long end;
/** 临界值 */
private long temp = 1000000L;
public ForkJoinTask(long star, long end) {
this.star = star;
this.end = end;
}
@Override
protected Long compute() {
if ((end - star) < temp) {
Long sum = 0L;
for (Long i = star; i < end; i++) {
sum += i;
}
return sum;
}else {
// 使用ForkJoin 分而治之 计算
long middle = (star + end) / 2;
ForkJoinTask forkJoinTask1 = new ForkJoinTask(star, middle);
// 拆分任务，把线程压入线程队列
forkJoinTask1.fork();
ForkJoinTask forkJoinTask2= new ForkJoinTask(middle, end);
forkJoinTask2.fork();
long taskSum = forkJoinTask1.join() + forkJoinTask2.join();
return taskSum;
}
}
}
public class ForkJoinTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask forkJoinTask = new ForkJoinTask(0L, 1_0000_0000L);
java.util.concurrent.ForkJoinTask submit = forkJoinPool.submit(forkJoinTask);
Long result = submit.get();
System.out.println(result);
}
}
异步回调
即Future，设计的初衷： 对将来的某个事件的结果进行建模
没有返回值的runAsync异步回调
public class FutureTest1 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture voidCompletableFuture = CompletableFuture.runAsync(() -> {
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " runAsync--->void");
});
System.out.println("111111");
System.out.println(voidCompletableFuture.get()); // 获取异步执行结果
}
}
有返回值的异步回调supplyAsync
package com.rainhey.juc;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class supplyAsyncTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName() + "supplyAsync=>Integer");
int i = 10 / 0;
return 1024;
});
//设置integerCompletableFuture的回调
System.out.println(integerCompletableFuture.whenComplete((t, u) -> {
System.out.println("t=>" + t);// 成功结果
System.out.println("u=>" + u);// 错误信息：
}).exceptionally((e) -> {
System.out.println(e.getMessage());
return 233;
}).get()); //获取回调成功或者失败的返回结果
}
}
JMM
JMM即Java内存模型
关于JMM的一些同步的约定：
- 线程解锁前，必须把共享变量立刻刷回主存；
- 线程加锁前，必须读取主存中的最新值到工作内存中；
- 加锁和解锁是同一把锁；
内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可再分的
- Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
- load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；
- Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；
- assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；
- store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；
- write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
- lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；
- unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
JMM对这八种指令的使用，制定了如下规则：
- 不允许read和load、store和write操作之一单独出现，必须成对使用。即使用了read必须load，使用了store必须write
- 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
- 不允许一个线程将没有assign的数据从工作内存同步回主内存
- 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
- 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
- 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
- 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量对一个变量进行unlock操作之前，必须把此变量同步回主内存
Volatile
- 保证可见性
package com.rainhey.juc;
import javax.swing.plaf.nimbus.State;
import java.beans.IntrospectionException;
import java.util.concurrent.TimeUnit;
public class JMMTest2 {
private volatile static int num=0; //没有volatile则程序一直死循环
public static void main(String[] args) {
new Thread(()->{
while(num==0){
};}).start();
try {
TimeUnit.SECONDS.sleep(3);
}catch (Exception e){
e.printStackTrace();
}
num=1;
System.out.println(num);
}
}
- 不保证原子性
package com.rainhey.juc;
import jdk.nashorn.internal.ir.WhileNode;
import javax.xml.ws.soap.Addressing;
public class JMMTest1 {
private static int number=0;
public static void add(){
number++;
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(number);
}
}
如果不加lock和synchronized ，怎么样保证原子性？
使用原子类，保证原子性
package com.rainhey.juc;
import jdk.nashorn.internal.ir.WhileNode;
import javax.xml.ws.soap.Addressing;
import java.util.concurrent.atomic.AtomicInteger;
public class JMMTest1 {
private static AtomicInteger number=new AtomicInteger();
public static void add(){
number.incrementAndGet(); //底层是CAS，保证原子性
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(number);
}
}
禁止指令重排
指令重排：我们写的程序，计算机并不是按照我们自己写的那样去执行的
源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行
volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序
内存屏障：CPU指令，作用是保证特定的操作的执行顺序；可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）
单例模式中内存屏障用得很多
CAS
CAS详解1
CAS详解2
CAS详解3
public class CASTest {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022);
// CAS 比较并交换， 期望，更新
/* public final boolean compareAndSet(int expect, int update)*/
// 如果和期望的值相同则更新，否则就不更新，CAS是计算机的并发原语
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2022, 2024));
System.out.println(atomicInteger.get());
atomicInteger.getAndIncrement(); // ++
}
}
unsafe类
点开getAndIncrement方法
点开unsafe类
Java无法操作内存，unsafe类可以看作是Java的后门，Java通过unsafe类调用底层的C++代码操作内存
点开getAndAddInt方法
自旋锁，获取主存中的值并和预期值比较，相同则用新值替换，否则就一直循环
CAS缺点：
- 循环会耗时；
- 一次性只能保证一个共享变量的原子性；
- 它会存在ABA问题
原子引用
带版本号的原子操作，解决ABA问题，思想是乐观锁
package com.rainhey.juc;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABATest {
public static void main(String[] args) {
AtomicStampedReference stampedReference = new AtomicStampedReference<>(1,1);
new Thread(()->{
int stamp = stampedReference.getStamp();
System.out.println("a1-->"+"stamp="+stamp);
try {
TimeUnit.SECONDS.sleep(1);
}catch (Exception e){
e.printStackTrace();
}
System.out.println(stampedReference.compareAndSet(1, 2, stampedReference.getStamp(), stampedReference.getStamp() + 1));
System.out.println("a2-->"+"stamp="+stampedReference.getStamp());
System.out.println(stampedReference.compareAndSet(2, 1, stampedReference.getStamp(), stampedReference.getStamp() + 1));
System.out.println("a3-->"+"stamp="+stampedReference.getStamp());
}).start();
new Thread(()->{
int stamp = stampedReference.getStamp(); // 获得版本号
System.out.println("b1-->"+"stamp="+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(stampedReference.compareAndSet(1, 3,
stamp, stamp + 1));
System.out.println("b1-->stamp=" + stampedReference.getStamp());
}).start();
}
}
自旋锁
自己写一个简单自旋锁加深理解
package com.rainhey.juc;
import java.util.concurrent.atomic.AtomicReference;
public class SpinLockDemo {
//默认引用为null
AtomicReference threadAtomicReference = new AtomicReference<>();
//加锁
public void myLock(){
System.out.println(Thread.currentThread().getName()+"--->myLock");
while(!threadAtomicReference.compareAndSet(null, Thread.currentThread())){
}
}
//解锁
public void myUnlock(){
System.out.println(Thread.currentThread().getName()+"--->myUnLock");
threadAtomicReference.compareAndSet(Thread.currentThread(), null);
}
}
package com.rainhey.juc;
import java.util.concurrent.TimeUnit;
public class MyLockTest {
public static void main(String[] args) {
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(()->{
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnlock();
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myLock();
spinLockDemo.myUnlock();
}).start();
}
}
