JUC并发编程-锁分类

JUC并发编程-锁分类 锁分类 公平和非公平锁

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来决定是公平锁还是非公平锁，默认是非公平锁

公平锁

公平锁，在并发环境下，每个线程在获取锁的时候会去查看此锁维护的等待队列，如果为空，或者当前线程为等待队列的第一个，就占有锁，否则加入到等待队列里，然后按照FIFO(先进先出)的规则等待

非公平锁

不公平，上来就直接尝试占有锁，就想插队，如果插不上，就再采用类似公平锁的方式，例如synchronized

---

可重入锁（又名递归锁）

指同一个线程在获得锁之后，遇到需要相同锁的同步代码，会自动获取锁。

线程可以进入任何一个他已经拥有的锁所同步的代码块

---

自旋锁

尝试获取锁的线程没拿到锁之后不会立即阻塞，而是采用循环的方式尝试获取锁，可以减少线程上下文切换，消耗cpu性能

public class SpinLockDemo {

    AtomicReference atomicReference=new AtomicReference();

    public void myLock(){
        //获取当前线程
        Thread thread=Thread.currentThread();

        while (!atomicReference.compareAndSet(null, thread)){

        }
        System.out.println(Thread.currentThread().getName()+"获得锁");


    }

    public void unLock(){
        Thread thread=Thread.currentThread();

        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"解锁");
    }

    public static void main(String[] args) throws InterruptedException {

        SpinLockDemo spinLockDemo=new SpinLockDemo();


        new Thread(()->{
            spinLockDemo.myLock();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unLock();

        },"t1").start();

        Thread.sleep(1000);

        new Thread(()->{
            spinLockDemo.myLock();

            spinLockDemo.unLock();

        },"t2").start();

    }

}

---

独占锁(写锁)/共享锁(读锁)/互斥锁

独占锁：指该锁一次只能被一个线程所持有、对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可被多个线程所持有

互斥锁：读锁的共享锁可以保证并发读是非常高效的，读写、写读、写写的过程是互斥的

---

ReentrantReadWriteLock其读锁是共享锁，写锁是独占锁

为了增加并发性能，读取共享资源的时候可以同时进行，但是写入共享资源的时候，不允许其他线程对资源进行读写

读读共存读写互斥写写互斥

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {
            //匿名内部类使用外部的局部变量必须用final修饰保证数据的一致性，局部变量和内部类生命周期不一样
            final int tem=i;
            new Thread(()->{
                try {
                    myCache.put(tem+"",tem+"");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }


        for (int i = 0; i < 5; i++) {
            //匿名内部类使用外部的局部变量必须用final修饰保证数据的一致性，局部变量和内部类生命周期不一样
            final int tem=i;
            new Thread(()->{
                try {
                    myCache.get(tem+"");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

class MyCache{

    private volatile Map map=new HashMap<>();
    //可重入读写锁
    private  ReentrantReadWriteLock rwLock=new ReentrantReadWriteLock();

    public void put(String key,Object value) throws InterruptedException {
        //写锁
        rwLock.writeLock().lock();

        System.out.println(Thread.currentThread().getName()+": 正在写入");

        Thread.sleep(1000);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+": 写入完成");

        //
        rwLock.writeLock().unlock();
    }

    public void get(String key) throws InterruptedException {
        //读锁
        rwLock.readLock().lock();

        System.out.println(Thread.currentThread().getName()+": 读取中");
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+": 读取完成:"+map.get(key));

        //解锁
        rwLock.readLock().unlock();

    }

---