锁的概述

悲观锁

悲观锁比较悲观，当多个线程对共享数据实现修改的时候，谁能拿到锁，谁就能修改成功，最后只有一个线程才能修改成功。

乐观锁

乐观锁比较乐观，通过预值或者版本号比较，如果不一致性的情况则通过循环控制修改，当前线程不会被阻塞，是乐观，效率比较高。

公平与非公平锁

公平锁

比较公平，根据请求锁的顺序排列，先来请求的就先获取锁，后来的就最后获取锁，采用队列存放

非公平锁

不是根据请求的顺序排列，通过争抢的方式获取锁

New  ReentramtLock()(true)---公平锁
New  ReentramtLock()(false)---非公平锁

独占锁与共享锁

独占锁

在多线程中，只允许有一个线程获取到锁，其他线程都会等待

共享锁

多个线程可以同时持有锁，例如ReentrantLock读写锁

锁的可重入性

在同一个线程中锁可以不断传递的，可以直接获取

cas无锁机制

概念：Compare and Swap,比较并交换
CAS有3个操作数，内存值V，旧的预期值E，要修改的值N，当且当预期值E和内存值V相同时，将内存值V修改为N
V:共享变量值，主内存值
E:V的副本值，工作内存值
N:修改共享变量的值

1. Cas 是通过硬件指令，保证原子性
2. Java是通过unsafe jni技术
3. 原子类： AtomicBoolean，AtomicInteger，AtomicLong 等使用 CAS 实现。

public class Test002 extends Thread {
    private static AtomicLong atomicLong = new AtomicLong();

    @Override
    public void run() {
        while (atomicLong.get() < 10000) {
            long l = atomicLong.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + "," + l);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Long startTime=System.currentTimeMillis();
        Test002 t1 = new Test002();
        Test002 t2 = new Test002();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        Long endTime=System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
}

public final long getAndAddLong(Object var1, long var2, long var4) {
    long var6;
    do {
        var6 = this.getLongVolatile(var1, var2);
    } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

    return var6;
}

Var6是为旧的预期值:E值
Var1,Var2是共享变量 V值
Var6+Var4 是新的值 N值

原子类手写CAS无锁

package com.mayikt;

import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.IntStream;

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/21 16:28
 **/

public class AtomicTryLock {
    /**
     * 定义AtomicInteger  修改为1表示该锁已经被使用该 修改为0表示为被使用
     */
    private AtomicLong atomicLong = new AtomicLong(0);
    private Thread lockThread;

    public boolean tryLock() {
        boolean result = atomicLong.compareAndSet(0, 1);
        if (result) {
            lockThread = Thread.currentThread();
        }
        return result;
    }

    public boolean unLock() {
        if (lockThread != null && lockThread != Thread.currentThread()) {
            return false;
        }
        return atomicLong.compareAndSet(1, 0);
    }

    public static void main(String[] args) {
        AtomicTryLock atomicTryLock = new AtomicTryLock();
        IntStream.range(1, 10).forEach((i) -> new Thread(() -> {
            try {
                boolean result = atomicTryLock.tryLock();
                if (result) {
                    System.out.println(Thread.currentThread().getName() + ",获取锁成功~");
                } else {
                    System.out.println(Thread.currentThread().getName() + ",获取锁失败~");
                }
            } catch (Exception e) {
                e.printStackTrace();
                atomicTryLock.unLock();
            } finally {
                atomicTryLock.unLock();
            }
        }).start());
    }
}

Cas中的ABA问题

概念：因为cas主要检查内存值V与旧的预期值E是否一致，如果一致的情况下，则修改。这个时候就会存在ABA的问题
比如如果线程1将原来的A值改为了B,线程2又将B改为A,线程3发现V和E的值是相等的，发现没有变化的，但实际上是已经发生了变化的，这个就是ABA的问题
解决方案：通过版本号码，对每个变量更新的版本号码+1

AtomicMarkableReference类

package com.mayikt;

import java.util.concurrent.atomic.AtomicStampedReference;

public class Test004 {
    // 注意：如果引用类型是Long、Integer、Short、Byte、Character一定一定要注意值的缓存区间！
    // 比如Long、Integer、Short、Byte缓存区间是在-128~127，会直接存在常量池中，而不在这个区间内对象的值则会每次都new一个对象，那么即使两个对象的值相同，CAS方法都会返回false
    // 先声明初始值，修改后的值和临时的值是为了保证使用CAS方法不会因为对象不一样而返回false
    private static final Integer INIT_NUM = 1000;
    private static final Integer UPDATE_NUM = 100;
    private static final Integer TEM_NUM = 200;
    private static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(INIT_NUM, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            Integer value = (Integer) atomicStampedReference.getReference();
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " : 当前值为：" + value + " 版本号为：" + stamp);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // value 旧值 内存中的值   UPDATE_NUM 修改的值
            if (atomicStampedReference.compareAndSet(value, UPDATE_NUM, 1, stamp + 1)) {
                System.out.println(Thread.currentThread().getName() + " : 当前值为：" + atomicStampedReference.getReference() + " 版本号为：" + atomicStampedReference.getStamp());
            } else {
                System.out.println("版本号不同，更新失败！");
            }
        }, "线程A").start();
    }
}

参考：蚂蚁课堂