/**
 * 獨(dú)占鎖（寫(xiě)鎖） 一次只能被一個(gè)線(xiàn)程占有
 * 共享鎖（讀鎖） 多個(gè)線(xiàn)程可以同時(shí)占有
 * ReadWriteLock
 * 讀-讀  可以共存！
 * 讀-寫(xiě)  不能共存！
 * 寫(xiě)-寫(xiě)  不能共存！
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        // 寫(xiě)入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        // 讀取
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}

// 加鎖的
class MyCacheLock {
    private volatile Map<String, Object> map = new HashMap<>();
    // 讀寫(xiě)鎖： 更加細(xì)粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();

    // 存，寫(xiě)入的時(shí)候，只希望同時(shí)只有一個(gè)線(xiàn)程寫(xiě)
    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "寫(xiě)入" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "寫(xiě)入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    // 取，讀，所有人都可以讀！
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "讀取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "讀取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

/**
 * 自定義緩存
 */
class MyCache {

    private volatile Map<String, Object> map = new HashMap<>();

    // 存，寫(xiě)
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "寫(xiě)入" + key);
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "寫(xiě)入OK");
    }

    // 取，讀
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "讀取" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "讀取OK");
    }
}

package com.nie.juc.cas;/*
 *
 *@auth  wenzhao
 *@date 2021/4/25  17:19
 */

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 演示 aba 的問(wèn)題
 * （1）第一個(gè)參數(shù) expectedReference：表示預(yù)期值。
 * （2）第二個(gè)參數(shù) newReference：表示要更新的值。
 * （3）第三個(gè)參數(shù) expectedStamp：表示預(yù)期的時(shí)間戳。
 * （4）第四個(gè)參數(shù) newStamp：表示要更新的時(shí)間戳。
 */
public class CASDemo {

    //AtomicStampedReference 注意，如果泛型是一個(gè)包裝類(lèi)，注意對(duì)象的引用問(wèn)題
    // 注意：如果引用類(lèi)型是 Long、Integer、Short、Byte、Character 一定一定要注意值的緩存區(qū)間！
    // 比如 Long、Integer、Short、Byte 緩存區(qū)間是在-128~127，
    // 會(huì)直接存在常量池中，而不在這個(gè)區(qū)間內(nèi)對(duì)象的值 則會(huì)每次都 new 一個(gè)對(duì)象，
    // 那么即使兩個(gè)對(duì)象的值相同，CAS 方法都會(huì)返回 false
    // 先聲明初始值，修改后的值和臨時(shí)的值是為了保證使用 CAS 方法不會(huì)因?yàn)閷?duì)象不一樣而返回 false


    // 正常在業(yè)務(wù)操作，這里面比較的都是一個(gè)個(gè)對(duì)象
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

    // CAS  compareAndSet : 比較并交換！
    public static void main(String[] args) {
        ;
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp(); // 獲得版本號(hào)
            System.out.println("a1=>" + stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Lock lock = new ReentrantLock(true);

            atomicStampedReference.compareAndSet(1, 2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);

            System.out.println("a2=>----" + atomicStampedReference.getStamp());


            System.out.println("更改" + atomicStampedReference.compareAndSet(2, 1,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));

            System.out.println("a3=>" + atomicStampedReference.getStamp());

        }, "a").start();


        // 樂(lè)觀鎖的原理相同！
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp(); // 獲得版本號(hào)
            System.out.println("b1=>" + stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("+++++++++++++++++++++++++++++++++++++++++++++");
            System.out.println(atomicStampedReference.compareAndSet(1, 6,
                   stamp, stamp + 1));

            System.out.println("b2=>" + atomicStampedReference.getStamp());

        }, "b").start();

    }
}

a1=>1
b1=>1
a2=>----2
更改true
a3=>3
+++++++++++++++++++++++++++++++++++++++++++++
false
b2=>3

package com.nie.juc.cas;/*
 *
 *@auth  wenzhao
 *@date 2021/4/25  20:36
 */

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

public class AtomicTryLock {
    private AtomicLong cas = new AtomicLong(0);
    private Thread lockCurrentThread;

    /**
     * 1 表示鎖已經(jīng)被獲取
     * 0 表示鎖沒(méi)有獲取
     * 利用 cas 將 0 改為 1 成功則表示獲取鎖
     *
     * @return
     */

    //加鎖
    private boolean tryLock() {
        boolean result = cas.compareAndSet(0, 1);
        if (result) {
            lockCurrentThread = Thread.currentThread();
        }
        return result;
    }

    //釋放鎖
    private boolean unLock() {
        if (lockCurrentThread != Thread.currentThread()) {
            return false;
        }
        return cas.compareAndSet(0, 1);
    }

    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) {
                    atomicTryLock.lockCurrentThread = Thread.currentThread();
                    System.out.println(Thread.currentThread().getName() + ",獲取鎖成功~");
                } else {
                    System.out.println(Thread.currentThread().getName() + ",獲取鎖失敗~");
                }
            } catch (Exception e) {
            } finally {
                //釋放鎖
                if (atomicTryLock != null) {
                    atomicTryLock.unLock();
                }
            }
        }).start());
    }

}

Thread-0,獲取鎖成功~
Thread-3,獲取鎖失敗~
Thread-2,獲取鎖失敗~
Thread-1,獲取鎖失敗~
Thread-4,獲取鎖失敗~
Thread-7,獲取鎖失敗~
Thread-8,獲取鎖失敗~
Thread-6,獲取鎖失敗~
Thread-5,獲取鎖失敗~