记录一下**公平锁，非公平锁，可重入锁（递归锁），读写锁，**自旋锁****的概念，以及一些和锁有关的java类。
公平锁与非公平锁：
公平锁就是在多线程环境下，每个线程在获取锁时，先查看这个锁维护的队列，如果队列为空或者自身就是等待队列的第一个，就占有锁。否则就加入到等待队列中，按照FIFO的顺序依次占有锁。
非公平锁会一上来就试图占有锁，如果占有失败，再按照公平锁的方式等待。
公平锁和非公平锁可以用 Lock lock = new ReentrantLock(boolean fair)的方式创建（默认为非公平锁，相当于fair为false）。Synchronized是一种非公平锁。非公平锁的优点在于吞吐量比公平锁大
1java.util.concurrent.locks.ReentrantLock$FairSync.java 2//公平获取锁 3protected final boolean tryAcquire( int acquires) { 4 final Thread current = Thread.currentThread(); 5 int c = getState(); 6 //状态为0，说明当前没有线程占有锁 7 if (c == 0 ) { 8 //如果当前线程是等待队列的第一个或者等待队列为空，则通过cas指令设置state为1，当前线程获得锁 9 if (isFirst(current) && 10 compareAndSetState( 0 , acquires)) { 11 setExclusiveOwnerThread(current); 12 return true ; 13 } 14 } 15//如果当前线程本身就持有锁，那么叠加状态值，持续获得锁 16 else if (current == getExclusiveOwnerThread()) { 17 int nextc = c + acquires; 18 if (nextc < 0 ) 19 throw new Error( "Maximum lock count exceeded" ); 20 setState(nextc); 21 return true ; 22 } 23 //以上条件都不满足，那么线程进入等待队列。 24 return false ; 25} 26 27 28//非公平占有锁 29 final boolean nonfairTryAcquire(int acquires) { 30 final Thread current = Thread.currentThread(); 31 int c = getState(); 32 if (c == 0) { 33 //如果当前没有线程占有锁，当前线程直接通过cas指令占有锁 34 if (compareAndSetState(0, acquires)) { 35 setExclusiveOwnerThread(current); 36 return true; 37 } 38 } 39 else if (current == getExclusiveOwnerThread()) { 40 int nextc = c + acquires; 41 if (nextc < 0) // overflow 42 throw new Error("Maximum lock count exceeded"); 43 setState(nextc); 44 return true; 45 } 46 return false; 47 }
可重入锁：
可重入锁又叫递归锁，其实就是ReentrantLock。reentrant 译为可重入，意味着线程可以进入它已经拥有的锁的同步代码块。
同一个线程在外层方法获取锁的时候，在进入内层方法仍然会自动获取锁。
它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。这模仿了 synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续） synchronized 块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个 synchronized 块时，才释放锁。
下面引用一个可重入锁和不可重入的设计（https://blog.csdn.net/u012545728/article/details/80843595）
1//可重入锁的设计 2public class MyReentrantLock{ 3 boolean isLocked = false; 4 Thread lockedBy = null; 5 int lockedCount = 0; 6 public synchronized void lock() 7 throws InterruptedException{ 8 Thread thread = Thread.currentThread(); 9 while(isLocked && lockedBy != thread){ 10 wait(); 11 } 12 isLocked = true; 13 lockedCount++; 14 lockedBy = thread; 15 } 16 public synchronized void unlock(){ 17 if(Thread.currentThread() == this.lockedBy){ 18 lockedCount--; 19 if(lockedCount == 0){ 20 isLocked = false; 21 notify(); 22 } 23 } 24 } 25} 26 27//不可重入锁的设计 28public class UnReentrantLock{ 29 private boolean isLocked = false; 30 public synchronized void lock() throws InterruptedException{ 31 while(isLocked){ 32 wait(); 33 } 34 isLocked = true; 35 } 36 public synchronized void unlock(){ 37 isLocked = false; 38 notify(); 39 } 40}
自旋锁：
是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，直到获取到锁。
自旋锁的优点是不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换。
自旋锁的缺点是如果一个线程长时间不释放锁，就会使其它线程循环等待，消耗CPU。不公平的锁无法满足等待时间最长的线程优先获取锁，可能存在“线程饥饿”问题。
自旋锁的代码实现：
1 1 public class SpinLockDemo { 2 2 private AtomicReference<Thread> atomicReference= new AtomicReference<>(); 3 3 4 4 public void myLock(){ 5 5 Thread thread = Thread.currentThread(); 6 6 //在期望线程是null的时候,设置为当前进程,退出循环,其他线程进来将进入循环 7 7 while (!atomicReference.compareAndSet(null,thread)){ 8 8 System.out.println(Thread.currentThread().getName()+"线程等待中"); 9 9 } 1010 System.out.println(Thread.currentThread().getName()+"线程进入"); 1111 1212 } 1313 1414 public void myUnlock(){ 1515 Thread thread = Thread.currentThread(); 1616 //将原子线程引用的当前线程设置为null时才会退出循环 1717 System.out.println(Thread.currentThread().getName()+"线程结束"); 1818 while (!atomicReference.compareAndSet(thread,null)){ 1919 } 2020 } 2121 2222 public static void main(String[] args){ 2323 SpinLockDemo spinLockDemo = new SpinLockDemo(); 2424 new Thread(()->{ 2525 spinLockDemo.myLock(); 2626 try { 2727 TimeUnit.MICROSECONDS.sleep(300); 2828 } catch (InterruptedException e) { 2929 e.printStackTrace(); 3030 } 3131 spinLockDemo.myUnlock(); 3232 },"t1").start(); 3333 3434 new Thread(()->{ 3535 spinLockDemo.myLock(); 3636 try { 3737 TimeUnit.MICROSECONDS.sleep(300); 3838 } catch (InterruptedException e) { 3939 e.printStackTrace(); 4040 } 4141 spinLockDemo.myUnlock(); 4242 },"t2").start(); 4343 } 4444 }
运行结果：
1t1线程进入 2t2线程等待中 3t2线程等待中 4t2线程等待中 5t2线程等待中 6t2线程等待中 7t2线程等待中 8t1线程结束 9t2线程进入 10t2线程结束
读写锁：
读锁为共享锁，写锁为排它锁。java中可以使用ReentrantReadWriteLock来实现。
引入几点总结：
(a).重入方面其内部的WriteLock可以获取ReadLock，但是反过来ReadLock想要获得WriteLock则永远都不要想。
(b).WriteLock可以降级为ReadLock，顺序是：先获得WriteLock再获得ReadLock，然后释放WriteLock，这时候线程将保持Readlock的持有。反过来ReadLock想要升级为WriteLock则不能。
(c).ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock，而WriteLock则是完全的互斥。这一特性最为重要，因为对于高读取频率而相对较低写入的数据结构，使用此类锁同步机制可以提高并发量。
(d).不管是ReadLock还是WriteLock都支持Interrupt，语义与ReentrantLock一致。
(e).WriteLock支持Condition并且与ReentrantLock语义一致，而ReadLock则不能使用Condition，否则抛出UnsupportedOperationException异常。
读写锁的例子：
1 1 public class ReadAndWriteLock { 2 2 3 3 static class MyCache{ 4 4 private volatile Map<String,Object> cache = new HashMap<>(); 5 5 private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); 6 6 7 7 //模仿缓存中的写入,使用写锁 8 8 public void put(String key,Object value){ 9 9 rwLock.writeLock().lock(); 1010 try { 1111 System.out.println(Thread.currentThread().getName()+"线程正在写入["+key+"]"); 1212 cache.put(key,value); 1313 try { TimeUnit.MICROSECONDS.sleep(200); }catch (InterruptedException e){} 1414 System.out.println(Thread.currentThread().getName()+"写入完成"); 1515 }finally { 1616 rwLock.writeLock().unlock(); 1717 } 1818 } 1919 //模仿缓存中的读取,使用读锁 2020 public void get(String key){ 2121 rwLock.readLock().lock(); 2222 try { 2323 System.out.println(Thread.currentThread().getName() + "线程正在读取"); 2424 try { 2525 TimeUnit.MICROSECONDS.sleep(200); 2626 } catch (InterruptedException e) { 2727 } 2828 System.out.println(Thread.currentThread().getName() + "线程读取完成"); 2929 }finally { 3030 rwLock.readLock().unlock(); 3131 } 3232 } 3333 } 3434 //测试方法 3535 public static void main(String[] args) { 3636 MyCache myCache = new MyCache(); 3737 //5个线程写入,5个线程读取 3838 for (int i = 1; i <= 5 ; i++) { 3939 final int temp = i; 4040 new Thread(()->{ 4141 myCache.put(temp+"","线程"+temp); 4242 },String.valueOf(i)).start(); 4343 } 4444 for (int i = 1; i <= 5 ; i++) { 4545 final int temp = i; 4646 new Thread(()->{ 4747 myCache.get(temp+""); 4848 },String.valueOf(i)).start(); 4949 } 5050 } 5151 }
运行结果：
11线程正在写入[1] 21写入完成 33线程正在写入[3] 43写入完成 55线程正在写入[5] 65写入完成 72线程正在写入[2] 82写入完成 92线程正在读取 101线程正在读取 115线程正在读取 124线程正在读取 134线程读取完成 142线程读取完成 151线程读取完成 165线程读取完成 174线程正在写入[4] 184写入完成 193线程正在读取 203线程读取完成