面试系列----JUC中常见的锁

面试系列----JUC中常见的锁

1.公平锁和非公平锁

公平锁：是指多个线程按照申请锁的顺序来获取锁类似排对打饭，先来后到

非公平锁：是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象

并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁 默认是非公平锁，通过构造哈数指定该锁是否是公平锁 默认是非公平锁 非公平锁的优点在于吞吐量必公平锁大

两者的区别：

公平锁就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空或者当前等待队列的第一个，就占锁，否则就会加入到等待队列中，以后会按照FIFO的规则中获取每一个线程。

非公平锁：非公平锁就比较粗鲁，当需要锁的时候，就跳过队列中其他线程的等待，直接去获取锁，如果失败就在采用公平锁的这种方式。

2.可重入锁（递归锁）

可重入锁：是指同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取到锁，内层方法会自动的获取锁，也即是说，线程可以进入任何一个它已经拥有锁所在的同步代码块中。其中ReentrantLock/synchronized就是一个典型的可重入锁。可重入锁最大的作用就是可以避免死锁。

下面代码验证synchronized和ReentrantLock锁

class Phone implements Runnable{

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\tsendSms");
        sendEmails();
    }

    public synchronized void sendEmails() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\tsendEmail");
    }

}

public class ReenterLockDemo {

    public static void main(String[] args) {

        Phone phone = new Phone();

   new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(() -> {
            try {

                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();



    }
}

class Phone implements Runnable{

    Lock lock = new ReentrantLock();


    @Override
    public void run() {
        get();
    }


    public void get(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\tget");
            set();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\tset");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

public class ReenterLockDemo {

    public static void main(String[] args) {

        Phone phone = new Phone();

     
        Thread t3 = new Thread(phone,"t3");
        Thread t4 = new Thread(phone,"t4");

        t3.start();
        t4.start();



    }
}

3.自旋锁

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处就是减少线程上下文切换的消耗，缺点是是循环会消耗CPU

手写一个自旋锁

public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void mylock(){
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"\tcome in");
        //自旋判断
        while (! atomicReference.compareAndSet(null,thread)){
            
        }
    }

    public void myunlock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName()+"\tinvoked unlock");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.mylock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myunlock();
        },"t1").start();


        new Thread(() -> {
            spinLockDemo.mylock();
            spinLockDemo.myunlock();
        },"t2").start();
    }
}

4.独占锁(写)/共享锁(读)

独占锁：指该锁一次只能有一个线程持有。对于ReentranLock和Synchronized而言就是独占锁。

共享锁：指该锁可以被多个线程持有。对于ReentrantReadWriteLock其中读锁就是共享锁，写锁是独占锁。

在多个线程同时操作 一个资源类没有任何问题 所以为了满足并发量读取共享资源应该可以同时进行，但是如果有一个线程想去写共享资源来 就不应该有其他线程可以对资源进行读或写。

下面是一个读写锁的demo

class MyCaChe{

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

    ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public void write(String key,Object object){
        reentrantReadWriteLock.writeLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);

            map.put(key,object);
            TimeUnit.MILLISECONDS.sleep(300);
            System.out.println(Thread.currentThread().getName() + "\t写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }

    }

    public void read(String key){

        reentrantReadWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + "\t正在读取");
            TimeUnit.MILLISECONDS.sleep(300);

            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t正在完成"+o);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }

    }

}

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCaChe myCaChe = new MyCaChe();

        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() ->{
                myCaChe.write(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() ->{
                myCaChe.read(temp+"");
            },String.valueOf(i)).start();
        }

    }
}