java中的锁

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

公平锁与非公平锁：

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

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

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

java.util.concurrent.locks.ReentrantLock$FairSync.java
//公平获取锁
protected final boolean tryAcquire( int acquires) {
     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(int acquires) {
            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 class MyReentrantLock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;
    public synchronized void lock()
            throws InterruptedException{
        Thread thread = Thread.currentThread();
        while(isLocked && lockedBy != thread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = thread;
    }
    public synchronized void unlock(){
        if(Thread.currentThread() == this.lockedBy){
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }
}

//不可重入锁的设计
public class UnReentrantLock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){    
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}

自旋锁：

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

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

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

自旋锁的代码实现：

 1 public class SpinLockDemo {
 2     private  AtomicReference<Thread> atomicReference= new AtomicReference<>();
 3 
 4     public void myLock(){
 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 void myUnlock(){
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 void main(String[] args){
23         SpinLockDemo spinLockDemo = new SpinLockDemo();
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 class ReadAndWriteLock {
 2 
 3     static class MyCache{
 4         private volatile Map<String,Object> cache = new HashMap<>();
 5         private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
 6 
 7         //模仿缓存中的写入,使用写锁
 8         public void put(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 void get(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 void main(String[] args) {
36         MyCache myCache = new MyCache();
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线程读取完成

posted @ 2019-04-27 23:27 有梦想的人不睡觉s 阅读(218) 评论(0) 编辑收藏举报

刷新页面返回顶部

DREAM IT POSSIBLE

when you dreams come alive you're unstoppable

java中的锁

公告