Java高并发下锁的分类介绍

Java中的锁介绍:   公平非公平锁、递归锁、自旋锁、读写锁(互斥锁)

公平锁：

每个线程在获取锁时会查看此锁维护的等待队列，若为空或者当前线程是等待队列中的第一个，就占有锁，否则就加入等待队列 多线程按申请锁的顺序来获取锁，顺序策略（队列先来后到）

非公平锁

上来就直接尝试占有锁，若尝试失败，则采用公平锁的方式 多线程获取锁的顺序并不是按照申请锁的顺序，高并发情况下,可能会造成优先级反转或饥饿现象 ReentrantLock默认非公平，synchronized是一种非公平锁

反转：并不是按照顺序来获取锁，允许加塞 饥饿：线程一直获取不到锁

可重入锁(递归锁)，避免了死锁

ReentrantLock/synchronized默认可重入锁 同一个线程外层函数获取锁的时候，在进入内层方法会自动获取锁（在同步方法中调用同步方法会自动获取锁，因为是同一把锁）

public synchronized void method1() { method2(); } public synchronized void method2(){ } Lock lock=new ReentrantLock(); public void M() { lock.lock(); lock.lock(); try { System.out.println(); }finally { lock.unlock(); lock.unlock(); } }

Lock加锁在finally中解锁防止线程抛出异常 锁可以重复加，但注意加锁几次解锁几次(若加多次，关闭次数不对应，编译通过，运行出现阻塞)

自旋锁

尝试获取锁的线程不会立即阻塞，而是采用循环的方式去获取锁

优:循环获取直到成功为止，没有类似的wait阻塞(减少线程上下文切换的消耗) 缺：循环会消耗CPU,若是一直不能获取锁，系统性能会下降

自旋锁的手动实现(CAS+自旋思想)

public class Main { AtomicReference<Thread> atReference=new AtomicReference<>(); public void lock() { Thread t=Thread.currentThread(); //第一个线程直接加锁,后续线程进入此循环 //缺点表现:若加锁线程执行时间过长,其余线程一直循环消耗CPU while(!atReference.compareAndSet(null, t)) { } } public void unlock() { Thread t=Thread.currentThread(); atReference.compareAndSet(t,null); }

读锁(共享锁)

该锁可被多个线程所持有，提高了并发性

写锁(独占锁)

该锁只能被一个线程所持有 (ReentrantLock、synchronized)

ReentrantReadWriteLock读锁是共享，写锁是独占 读写锁：读-读能共存，读-写不能共存，写-写不能共存

读写锁(互斥锁)示例：

class Cache{ private volatile Map<String,Object> cache=new HashMap<>(); private ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); public boolean set(String key,Object value) { lock.writeLock().lock(); try { cache.put(key, value); }finally { lock.writeLock().unlock(); } return true; } public Object get(String key){ Object value=null; lock.readLock().lock(); try { value=cache.get(key); }finally { lock.readLock().unlock(); } return value; } }

总结：synchronized是重锁， 并发性低，要有读写分离的思想