java锁公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁

1、java锁之公平锁/非公平锁

并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁 默认是非公平锁

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

1.1、为何要有公平锁与非公平锁？ 为何默认为非公平锁

• 恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU 的时间片，尽量减少 CPU 空闲状态时间。
• 使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当1个线程请求锁获取同步状态，然后释放同步状态，因为不需要考虑是否还有前驱节点，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。
• 公平锁保证了排队的公平性，所以就有可能导致排队的长时间在排队，也没有机会获取到锁。

1.2、如何选择？

• 如果为了更高的吞吐量，很显然非公平锁是比较合适的，因为节省很多线程切换时间，吞吐量自然就上去了；
  否则那就用公平锁，大家公平使用。

2、java锁之可重入锁(递归锁)

• 指的是同一线程外层函数获得锁之后，在内存递归函数依旧可以获取该锁的代码，即线程可以进入任何一个它已经拥有的锁所同步着代码块。作用可以帮助我们避免死锁。

class Phone{
    public synchronized void getEmail(){
        System.out.println(Thread.currentThread().getName()+"\t email");
    }
    public synchronized void getMessage(){
        System.out.println(Thread.currentThread().getName()+"\t messgae");
        getEmail();
    }
}
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
             try{
				//在t1线程中调用getMessage() 因为getMessage()中含有getEmail()方法 虽然getEmail()方法当中加锁了 但是在getMessage()当中 可以得到这个getEmail的锁
                phone.getMessage();
              }catch (Exception e) {
                 e.printStackTrace();
             }
        },"t1").start();
        new Thread(()->{
              try{
                phone.getMessage();
              }catch (Exception e) {
                  e.printStackTrace();
              }
        },"t2").start();
    }
}

3、自旋锁（spinlock）

• 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，可以帮助我们减少线程上下文切换的消耗，但是缺点是消耗CPU

package com.song.lockTest;

import org.omg.PortableServer.THREAD_POLICY_ID;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author 宋超
 * HP - the login name of the current user.
 * 2022/1/12 - the current system date.
 * 19:07 - the current system time.
 */
public class SpinLockDemo {

    //原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t come in");
        while(!atomicReference.compareAndSet(null,thread)){
            //System.out.println("我还在用哦！ 你等一会儿");
        }
    }
    public void myunLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getId()+"\t 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();
        }, "AAA").start();
        try { TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(()->{
            spinLockDemo.myLock();
            spinLockDemo.myunLock();
        }, "BBB").start();
    }

}

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

• 独占锁:指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁
• 共享锁:指该锁可被多个线程所持有。
• 对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。
• 读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

package com.song.lockTest;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 资源类
 */
class MyCaChe {
    /**
     * 保证可见性
     */
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    /**
     * 写
     *
     * @param key
     * @param value
     */
    public void put(String key, Object value) {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);
            //模拟网络延时
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t正在完成");
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }

    /**
     * 读
     *
     * @param key
     */
    public void get(String key) {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t正在读取");
            //模拟网络延时
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t正在完成" + result);
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }

    public void clearCaChe() {
        map.clear();
    }

}

/**
 * Description:
 * 多个线程同时操作 一个资源类没有任何问题 所以为了满足并发量
 * 读取共享资源应该可以同时进行
 * 但是
 * 如果有一个线程想去写共享资源来  就不应该有其他线程可以对资源进行读或写
 * <p>
 * 小总结:
 * 读 读能共存
 * 读 写不能共存
 * 写 写不能共存
 * 写操作 原子+独占 整个过程必须是一个完成的统一整体 中间不允许被分割 被打断
 *
 **/
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCaChe myCaChe = new MyCaChe();
        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++) {
            int finalI = i;
            new Thread(() -> {
                myCaChe.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}