狂神说 JUC并发编程

基本概念

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

1. 通过ForkJoinPool 来执行任务，可以调用其submit方法
   
2. 创建一个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

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<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();
    }
}