java中的锁demo_java中的锁

记录一下公平锁，非公平锁，可重入锁(递归锁)，读写锁，自旋锁的概念，以及一些和锁有关的java类。

公平锁与非公平锁：

公平锁就是在多线程环境下，每个线程在获取锁时，先查看这个锁维护的队列，如果队列为空或者自身就是等待队列的第一个，就占有锁。否则就加入到等待队列中，按照FIFO的顺序依次占有锁。

非公平锁会一上来就试图占有锁，如果占有失败，再按照公平锁的方式等待。

公平锁和非公平锁可以用  Lock lock = new ReentrantLock(boolean fair)的方式创建(默认为非公平锁，相当于fair为false)。Synchronized是一种非公平锁。非公平锁的优点在于吞吐量比公平锁大

java.util.concurrent.locks.ReentrantLock$FairSync.java//公平获取锁

protected final boolean tryAcquire( intacquires) {final Thread current =Thread.currentThread();int c =getState();//状态为0，说明当前没有线程占有锁

if (c == 0) {//如果当前线程是等待队列的第一个或者等待队列为空，则通过cas指令设置state为1，当前线程获得锁

if (isFirst(current) &&compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);return true;

}

}//如果当前线程本身就持有锁，那么叠加状态值，持续获得锁

else if (current ==getExclusiveOwnerThread()) {int nextc = c +acquires;if (nextc < 0)throw new Error( "Maximum lock count exceeded");

setState(nextc);return true;

}//以上条件都不满足，那么线程进入等待队列。

return false;

}//非公平占有锁

final boolean nonfairTryAcquire(intacquires) {final Thread current =Thread.currentThread();int c =getState();if (c == 0) {//如果当前没有线程占有锁，当前线程直接通过cas指令占有锁

if (compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);return true;

}

}else if (current ==getExclusiveOwnerThread()) {int nextc = c +acquires;if (nextc < 0) //overflow

throw new Error("Maximum lock count exceeded");

setState(nextc);return true;

}return false;

}

可重入锁：

可重入锁又叫递归锁，其实就是ReentrantLock。reentrant 译为可重入，意味着线程可以进入它已经拥有的锁的同步代码块。

同一个线程在外层方法获取锁的时候，在进入内层方法仍然会自动获取锁。

它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放。这模仿了 synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个(或者后续) synchronized 块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个 synchronized 块时，才释放锁。

下面引用一个可重入锁和不可重入的设计(https://blog.csdn.net/u012545728/article/details/80843595)

//可重入锁的设计

public classMyReentrantLock{boolean isLocked = false;

Thread lockedBy= null;int lockedCount = 0;public synchronized voidlock()throwsInterruptedException{

Thread thread=Thread.currentThread();while(isLocked && lockedBy !=thread){

wait();

}

isLocked= true;

lockedCount++;

lockedBy=thread;

}public synchronized voidunlock(){if(Thread.currentThread() == this.lockedBy){

lockedCount--;if(lockedCount == 0){

isLocked= false;

notify();

}

}

}

}//不可重入锁的设计

public classUnReentrantLock{private boolean isLocked = false;public synchronized void lock() throwsInterruptedException{while(isLocked){

wait();

}

isLocked= true;

}public synchronized voidunlock(){

isLocked= false;

notify();

}

}

自旋锁：

是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，直到获取到锁。

自旋锁的优点是不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换。

自旋锁的缺点是如果一个线程长时间不释放锁，就会使其它线程循环等待，消耗CPU。不公平的锁无法满足等待时间最长的线程优先获取锁，可能存在“线程饥饿”问题。

自旋锁的代码实现：

1 public classSpinLockDemo {2 private AtomicReference atomicReference= new AtomicReference<>();3

4 public voidmyLock(){5 Thread thread =Thread.currentThread();6 //在期望线程是null的时候,设置为当前进程,退出循环,其他线程进来将进入循环

7 while (!atomicReference.compareAndSet(null,thread)){8 System.out.println(Thread.currentThread().getName()+"线程等待中");9 }10 System.out.println(Thread.currentThread().getName()+"线程进入");11

12 }13

14 public voidmyUnlock(){15 Thread thread =Thread.currentThread();16 //将原子线程引用的当前线程设置为null时才会退出循环

17 System.out.println(Thread.currentThread().getName()+"线程结束");18 while (!atomicReference.compareAndSet(thread,null)){19 }20 }21

22 public static voidmain(String[] args){23 SpinLockDemo spinLockDemo = newSpinLockDemo();24 new Thread(()->{25 spinLockDemo.myLock();26 try{27 TimeUnit.MICROSECONDS.sleep(300);28 } catch(InterruptedException e) {29 e.printStackTrace();30 }31 spinLockDemo.myUnlock();32 },"t1").start();33

34 new Thread(()->{35 spinLockDemo.myLock();36 try{37 TimeUnit.MICROSECONDS.sleep(300);38 } catch(InterruptedException e) {39 e.printStackTrace();40 }41 spinLockDemo.myUnlock();42 },"t2").start();43 }44 }

运行结果：

t1线程进入

t2线程等待中

t2线程等待中

t2线程等待中

t2线程等待中

t2线程等待中

t2线程等待中

t1线程结束

t2线程进入

t2线程结束

读写锁：

读锁为共享锁，写锁为排它锁。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 public classReadAndWriteLock {2

3 static classMyCache{4 private volatile Map cache = new HashMap<>();5 private ReentrantReadWriteLock rwLock = newReentrantReadWriteLock();6

7 //模仿缓存中的写入,使用写锁

8 public voidput(String key,Object value){9 rwLock.writeLock().lock();10 try{11 System.out.println(Thread.currentThread().getName()+"线程正在写入["+key+"]");12 cache.put(key,value);13 try { TimeUnit.MICROSECONDS.sleep(200); }catch(InterruptedException e){}14 System.out.println(Thread.currentThread().getName()+"写入完成");15 }finally{16 rwLock.writeLock().unlock();17 }18 }19 //模仿缓存中的读取,使用读锁

20 public voidget(String key){21 rwLock.readLock().lock();22 try{23 System.out.println(Thread.currentThread().getName() + "线程正在读取");24 try{25 TimeUnit.MICROSECONDS.sleep(200);26 } catch(InterruptedException e) {27 }28 System.out.println(Thread.currentThread().getName() + "线程读取完成");29 }finally{30 rwLock.readLock().unlock();31 }32 }33 }34 //测试方法

35 public static voidmain(String[] args) {36 MyCache myCache = newMyCache();37 //5个线程写入,5个线程读取

38 for (int i = 1; i <= 5 ; i++) {39 final int temp =i;40 new Thread(()->{41 myCache.put(temp+"","线程"+temp);42 },String.valueOf(i)).start();43 }44 for (int i = 1; i <= 5 ; i++) {45 final int temp =i;46 new Thread(()->{47 myCache.get(temp+"");48 },String.valueOf(i)).start();49 }50 }51 }

运行结果：

1线程正在写入[1]

1写入完成

3线程正在写入[3]

3写入完成

5线程正在写入[5]

5写入完成

2线程正在写入[2]

2写入完成

2线程正在读取

1线程正在读取

5线程正在读取

4线程正在读取

4线程读取完成

2线程读取完成

1线程读取完成

5线程读取完成

4线程正在写入[4]

4写入完成

3线程正在读取

3线程读取完成