Lock详解

（一）Lock接口

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

(二) 四种获取锁方式

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
```
Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){
 
}finally{
    lock.unlock();   //释放锁
}
```
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
```
Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
   
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}
```
lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
```
public void method() throws InterruptedException {
  lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}
```

(三) ReentrantLock

ReentrantLock，意思是“可重入锁”。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

第一种获取锁方式：lock.lock()：
请求获取锁，如果没有释放锁，则第二个线程没法获取到锁，这种方式可能有死锁现象。

    public static void main(String[] args){

        Lock lock = new ReentrantLock();

        Buys buys = new Buys();
        buys.setTotal(100);

        MyThread2 dl1 = new MyThread2(buys, lock);
        MyThread2 dl2 = new MyThread2(buys, lock);
        MyThread2 dl3 = new MyThread2(buys, lock);
        MyThread2 dl4 = new MyThread2(buys, lock);
        MyThread2 dl5 = new MyThread2(buys, lock);
        MyThread2 dl6 = new MyThread2(buys, lock);

        dl1.start();
        dl2.start();
        dl3.start();
        dl4.start();
        dl5.start();
        dl6.start();
    }

public class MyThread2 extends Thread {

private Lock lock;

private Buys buys;
    public MyThread2(Buys buys, Lock lock){
        this.buys = buys;
        this.lock = lock;
    }

    @Override
    public void run() {
        lock.lock();
        System.out.println(this.getName()+":申请锁");
        try {
            long time = System.currentTimeMillis();
            buys.setTotal(buys.getTotal() - 20);
            System.out.println(this.getName()+":剩余："+buys.getTotal());
        }catch (Exception e){

        }finally {
            System.out.println(this.getName()+":释放锁");
            lock.unlock();
        }
    }
}

运行结果如下：

Thread-0:申请锁
Thread-0:剩余：80
Thread-0:释放锁
Thread-1:申请锁
Thread-1:剩余：60
Thread-1:释放锁
Thread-2:申请锁
Thread-2:剩余：40
Thread-2:释放锁
Thread-3:申请锁
Thread-3:剩余：20
Thread-3:释放锁
Thread-4:申请锁
Thread-4:剩余：0
Thread-4:释放锁
Thread-5:申请锁
Thread-5:剩余：-20
Thread-5:释放锁

第二种获取锁方式：lock.trylock()：
请求获取锁，有立即获取到返回值（无等待时间），如果成功获取到锁则返回true，否则返回false。该方式不会造成死锁，因为返回false时，线程直接中断。

    @Override
    public void run() {
        if(lock.tryLock()){
            System.out.println(this.getName()+":申请锁");
            try {
                long time = System.currentTimeMillis();
                buys.setTotal(buys.getTotal() - 20);
                System.out.println(this.getName()+":剩余："+buys.getTotal());
            }catch (Exception e){

            }finally {
                System.out.println(this.getName()+":释放锁");
                lock.unlock();
            }
        }else{
            System.out.println(this.getName()+":获取锁失败");
        }
    }

运行结果如下：

Thread-0:申请锁
Thread-0:剩余：80
Thread-0:释放锁
Thread-1:申请锁
Thread-2:获取锁失败
Thread-1:剩余：60
Thread-1:释放锁
Thread-4:申请锁
Thread-4:剩余：40
Thread-3:获取锁失败
Thread-5:获取锁失败
Thread-4:释放锁

从运行结果上分析，Thread-2、Thread-3、Thread-5由于没有抢占到资源被直接中断。

第三种获取锁方式：lock.tryLock(1, TimeUnit.NANOSECONDS)
第一个参数是时间数值，第二个参数是时间粒度

TimeUnit.DAYS          //天    
TimeUnit.HOURS         //小时    
TimeUnit.MINUTES       //分钟    
TimeUnit.SECONDS       //秒    
TimeUnit.MILLISECONDS  //毫秒   
TimeUnit.NANOSECONDS   //毫微秒  
TimeUnit.MICROSECONDS  //微秒

意思就是，请求获取锁，如果等待1毫微妙，仍然没有获取到锁，则返回false，否则返回true。该方式不会造成死锁，因为返回false时，线程直接中断。

第四种获取锁方式：lockInterruptibly()

    public static void main(String[] args){

        Lock lock = new ReentrantLock();

        Buys buys = new Buys();
        buys.setTotal(100);

        MyThread2 dl1 = new MyThread2(buys, lock);

        dl1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dl1.interrupt();
    }

public class MyThread2 extends Thread {

private Lock lock;

private Buys buys;
    public MyThread2(Buys buys, Lock lock){
        this.buys = buys;
        this.lock = lock;
    }

    @Override
    public void run() {

        try {
            for(int i=0;i<10000000;i++){
                doOption();
            }
        } catch (InterruptedException e) {
            System.out.println("InterruptedException异常："+this.getName()+":"+e.getMessage());
        }
    }

    private void doOption() throws InterruptedException {

        lock.lockInterruptibly();
        try {
            buys.setTotal(buys.getTotal() - 20);
        }catch (Exception e){
            System.out.println("Exception:"+e.getMessage());
        }finally {
            lock.unlock();
        }
    }
}

LZ对lockInterruptibly研究了很久，从多线程调试改成单线程调试，发现lockInterruptibly和interrupt()配合使用的，可以用代码主动控制中断的时间。其他三种获取锁的方式，只要线程执行了则不能中断，而lockInterruptibly却可以做到立即中断效果。（注：纯属个人理解，有错误请大佬们指出）

（四）ReentrantReadWriteLock

读写锁中的读锁：

public class MyThread2 extends Thread {

private ReadWriteLock lock;

private Buys buys;
    public MyThread2(Buys buys, ReadWriteLock lock){
        this.buys = buys;
        this.lock = lock;
    }

    @Override
    public void run() {

        for(int i=0;i<10;i++){
            doOption();
        }

    }

    private void doOption() {
        lock.readLock().lock();
        try {
            buys.setTotal(buys.getTotal() + 20);
            System.out.println("读操作："+this.getName()+"---"+buys.getTotal());
        }catch (Exception e){
            System.out.println("Exception:"+e.getMessage());
        }finally {
            lock.readLock().unlock();
        }
    }
}

    public static void main(String[] args){

        ReadWriteLock lock = new ReentrantReadWriteLock();
        Buys buys = new Buys();
        buys.setTotal(0);
        MyThread2 dl1 = new MyThread2(buys, lock);
        dl1.start();
        MyThread2 dl2 = new MyThread2(buys, lock);
        dl2.start();
    }

运行结果如下：

读操作：Thread-0---20
读操作：Thread-1---40
读操作：Thread-0---60
读操作：Thread-1---80
读操作：Thread-0---100
读操作：Thread-1---120
读操作：Thread-0---140
读操作：Thread-1---160
读操作：Thread-0---180
读操作：Thread-0---220
读操作：Thread-0---240
读操作：Thread-0---260
读操作：Thread-0---280
读操作：Thread-0---300
读操作：Thread-1---200
读操作：Thread-1---320
读操作：Thread-1---340
读操作：Thread-1---360
读操作：Thread-1---380
读操作：Thread-1---400

从运行结果来看，多线程用读锁可以加快运行效率。我们再来看看写锁。
读写锁中的写锁：（修改关键代码）

    private void doOption() {
        lock.writeLock().lock();
        try {
            buys.setTotal(buys.getTotal() + 20);
            System.out.println("写操作："+this.getName()+"---"+buys.getTotal());
        }catch (Exception e){
            System.out.println("Exception:"+e.getMessage());
        }finally {
            lock.writeLock().unlock();
        }
    }

运行结果如下：

写操作：Thread-0---20
写操作：Thread-0---40
写操作：Thread-0---60
写操作：Thread-0---80
写操作：Thread-0---100
写操作：Thread-0---120
写操作：Thread-0---140
写操作：Thread-0---160
写操作：Thread-0---180
写操作：Thread-0---200
写操作：Thread-1---220
写操作：Thread-1---240
写操作：Thread-1---260
写操作：Thread-1---280
写操作：Thread-1---300
写操作：Thread-1---320
写操作：Thread-1---340
写操作：Thread-1---360
写操作：Thread-1---380
写操作：Thread-1---400

从运行结果来看，如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁，则申请的线程会一直等待释放写锁。

最后呢，LZ想调试一下读写混用的代码的，但是想不到合适的场景，请求大神帮我想想场景，谢谢了。
如果发现有什么地方描述的不对，还请帮忙指出来谢谢。

最后编辑于：2018.06.19 18:18:39

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,088评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,715评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,361评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,099评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 60,987评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,063评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,486评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,175评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,440评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,518评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,305评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,190评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,550评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,880评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,152评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,451评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,637评论 2赞 335

Lock详解

（一）Lock接口

(二) 四种获取锁方式

(三) ReentrantLock

（四）ReentrantReadWriteLock

推荐阅读更多精彩内容