文章目录
基本概念
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<String> 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,
List<String> list = new Vector<>();
- 使用collections工具类,
List<String> list = Collections.synchronizedList(new ArrayList<>());
- CopyOnWrite,
List<String> list = new CopyOnWriteArrayList<>();
,写入复制
同理:并发访问set也会存在问题,解决方案也包括Set<String> set = Collections.synchronizedSet(new HashSet<>());
、Set<String> set = new CopyOnWriteArraySet<>();
同理:并发访问map也会存在问题,解决方案 Map<String, String> map = new ConcurrentHashMap<>();
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<String>{
@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<String,Object> 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<Runnable>()));
}
----------------------------------------------------------
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
----------------------------------------------------------
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
阿里巴巴开发者手册中有如下规范:
由于工具类提供的三种创建线程池的方法存在一些缺陷,建议手动创建线程池
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<User> 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<Long> {
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<Long> 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<Void> 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<Integer> 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
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<Integer> 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<Thread> 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();
}
}