多线程篇三（Lock锁）

前言
之前的文章我已经提到过一个jdk中的独占锁synchronized
synchronized是java的一个关键字，也就是java语言内置的特性。如果一个代码块被synchronized修饰，当一个线程获取到锁之后，其它需要获取该锁的线程便需要一直等待，等待获取锁的线程释放锁，获取锁的线程释放锁有三种情况：
1、持有锁的线程执行完代码块，然后线程会释放对锁的占有
2、线程执行抛出异常，此时JVM会让线程释放锁
3、持有锁的线程调用了wait()方法，在等待的时候立即释放锁。

正文
一、有了synchronized（内置锁）为什么还要使用Lock呢？
lock可以
1、尝试非阻塞的获取锁
2、获取锁的过程可以被中断
3、可以超时获取锁
二、java.util.concurrent.locks包下常用的类与接口

lock.jpg

根据上图，我们来逐一分析
1、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(); //获取一个新的Condition实例
}

（1）、lock()
lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此，一般来说，使用Lock必须在try…catch…块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生，并且获取锁的操作应该方法try的外面，防止误释放锁。
lock()方法使用模板

/**
 * Lock使用标准
 *
 * @Author YUBIN
 */
public class LockTemplete {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock(); // 可重入锁
        lock.lock();// 获取锁 放在try外面 防止释放了其它线程的锁
        try {
            // do my work ...
        }finally {
            lock.unlock(); // 释放锁
        }
    }
}

（2）、tryLock()、tryLock(time,unit)
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true；如果获取失败（即锁已被其他线程获取），则返回false，也就是说，这个方法无论如何都会立即返回（在拿不到锁时不会一直在那等待）。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
tryLock()使用模板

/**
 * tryLock()使用模板
 *
 * @Author YUBIN
 */
public class TryLockTemplate {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        if (lock.tryLock()) {
            try {
                // 获取到锁的处理逻辑
            } catch (Exception e) {
                // 异常处理
            } finally {
                lock.unlock();
            }
        } else {
            // 没有获取到锁的处理逻辑
        } 
    }
}

（3）、lockInterruptibly()
lockInterruptibly()方法比较特殊，尝试获取锁，获取锁的过程是可以中断的。举个例子有两个线程threadA和threadB都调用了lockInterruptibly()在同一时刻只会有一个线程获取到锁，假如threadA获取到了锁那么在threadA获取到锁到释放锁的过程中threadB是一直处于等待状态的，如果在threadA中调用了threadB.interrupt()中断方法能够中断threadB线程的等待状态。
由于lock.lockInterruptibly()的声明中抛出了中断异常，所以lock.lockInterruptibly()必须方法try/catch块中，或者在调用该方法的地方抛出异常，但推荐使用后者。
lockInterruptibly()方法使用模板

    public void method(Lock lock) throws InterruptedException {
        lock.lockInterruptibly();
        try {
            //执行代码
        } catch (Exception e) {
            // 异常处理
        } finally {
            lock.unlock();
        }
    }

2、ReentrantLock可重入锁
ReentrantLock，即可重入锁。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。
什么叫做可重入呢？最典型的一个例子就是递归的时候发生锁的重入。它是通过当前线程和一个整型变量来实现的。
具体的使用方法会在下面的基于Lock和Condition实现一个阻塞队列来演示。

3、ReadWritrLock
ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
    Lock readLock();  // 获取读锁

    Lock writeLock(); // 获取写锁
}

一个用来获取读锁，一个用来获取写锁。也就是说，将对临界资源的读写操作分成两个锁来分配给线程，从而使得多个线程可以同时进行读操作，当有一个线程获取了写锁，其它不管是需要获取读锁还是写锁的线程都是处于阻塞的。下面的 ReentrantReadWriteLock 实现了 ReadWriteLock 接口。
4、ReentrantReadWriteLock读写锁
ReentrantReadWriteLock 里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁ReadLock和写锁WriteLock。下面通过几个例子来看一下读写锁在读多写少的场景下与synchronized独占锁的区别
商品的实体类

public class Goods {
    private final String id;
    private Long totalSaleNumber; // 总销售数
    private Long depotNumber; // 当前库存数

    public Goods(String id, Long totalSaleNumber, Long depotNumber) {
        this.id = id;
        this.totalSaleNumber = totalSaleNumber;
        this.depotNumber = depotNumber;
    }

    public Long getTotalSaleNumber() {
        return totalSaleNumber;
    }

    public Long getDepotNumber() {
        return depotNumber;
    }

    public void setGoodsNumber(Long changeNumber) {
        this.totalSaleNumber += changeNumber;
        this.depotNumber -= changeNumber;
    }
}

操作商品数量的接口

public interface IGoodsNum {
    Goods getGoodsNumber();

    void setGoodsNumber(Long changeNumber);
}

使用synchronized操作商品数量

public class NumSync implements IGoodsNum {

    private Goods goods;

    public NumSync(Goods goods) {
        this.goods = goods;
    }

    @Override
    public synchronized Goods getGoodsNumber() {
        try {
            // 此处休眠5ms来演示从数据库中读取商品数据
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return goods;
    }

    @Override
    public synchronized void setGoodsNumber(Long changeNumber) {
        try {
            // 此处休眠50ms来演示修改商品的数量
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        goods.setGoodsNumber(changeNumber);
    }
}

使用ReentrantReadWriteLock操作商品数量

public class RwNumSync implements IGoodsNum {

    private Goods goods;

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    private final Lock rLock = lock.readLock(); // 获取读锁

    private final Lock wLock = lock.writeLock(); // 获取写锁

    public RwNumSync(Goods goods) {
        this.goods = goods;
    }

    @Override
    public Goods getGoodsNumber() {
        rLock.lock();
        try {
            SleepUtils.second(1);
            return goods;
        }finally {
            rLock.unlock();
        }
    }

    @Override
    public void setGoodsNumber(Long changeNumber) {
        wLock.lock();
        try {
            SleepUtils.second(50);
            goods.setGoodsNumber(changeNumber);
        }finally {
            wLock.unlock();
        }
    }
}

测试类

public class Test {
    private static final int threadRatio = 10; // 读线程与写线程的比例
    private static final int threadBaseCount = 3; // 写线程的数量
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    public static void main(String[] args) {
        Goods goods = new Goods("goods001", 100000L, 10000L);
        // 使用Synchronized操作商品数量
        IGoodsNum iGoodsNum = new NumSync(goods);
        // 使用ReentrantReadWriteLock操作商品的数量
        //IGoodsNum iGoodsNum = new RwNumSync(goods);
        for (int i = 0; i < threadBaseCount * threadRatio; i++) {
            Thread rThread = new Thread(new ReadThread(iGoodsNum));
            rThread.start();
        }
        for (int i = 0; i < threadBaseCount; i++) {
            Thread wThread = new Thread(new WriteThread(iGoodsNum));
            wThread.start();
        }
        countDownLatch.countDown();
    }

    // 读线程
    private static class ReadThread implements Runnable {

        private IGoodsNum iGoodsNum;

        public ReadThread(IGoodsNum iGoodsNum) {
            this.iGoodsNum = iGoodsNum;
        }

        @Override
        public void run() {
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100; i++) {
                iGoodsNum.getGoodsNumber();
            }
            long duration = System.currentTimeMillis() - start;
            System.out.println(Thread.currentThread().getName() + "读取库存数据耗时:" + duration);
        }
    }

    // 写线程
    private static class WriteThread implements Runnable {

        private IGoodsNum iGoodsNum;

        public WriteThread(IGoodsNum iGoodsNum) {
            this.iGoodsNum = iGoodsNum;
        }

        @Override
        public void run() {
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long start = System.currentTimeMillis();
            Random random = new Random();
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                iGoodsNum.setGoodsNumber(Long.valueOf(random.nextInt(10)));
            }
            long duration = System.currentTimeMillis() - start;
            System.out.println(Thread.currentThread().getName() + "写库存数据耗时:" + duration);
        }
    }
}

运行结果
（1）、使用Synchronized操作商品数量

Thread-22读取库存数据耗时:4428
Thread-31写库存数据耗时:5662
Thread-30写库存数据耗时:5882
Thread-21读取库存数据耗时:8202
Thread-32写库存数据耗时:8933
Thread-0读取库存数据耗时:12876
Thread-10读取库存数据耗时:13053
Thread-18读取库存数据耗时:13528
Thread-3读取库存数据耗时:13542
Thread-7读取库存数据耗时:13888
Thread-27读取库存数据耗时:14195
Thread-14读取库存数据耗时:14389
Thread-24读取库存数据耗时:14535
Thread-2读取库存数据耗时:14605
Thread-26读取库存数据耗时:14865
Thread-11读取库存数据耗时:15038
Thread-15读取库存数据耗时:15288
Thread-23读取库存数据耗时:15638
Thread-12读取库存数据耗时:15694
Thread-19读取库存数据耗时:15848
Thread-17读取库存数据耗时:15933
Thread-1读取库存数据耗时:16272
Thread-28读取库存数据耗时:16354
Thread-13读取库存数据耗时:16403
Thread-8读取库存数据耗时:16496
Thread-16读取库存数据耗时:16514
Thread-25读取库存数据耗时:16657
Thread-5读取库存数据耗时:16727
Thread-29读取库存数据耗时:16782
Thread-20读取库存数据耗时:16809
Thread-9读取库存数据耗时:16874
Thread-6读取库存数据耗时:16965
Thread-4读取库存数据耗时:17198

（2）、使用ReentrantReadWriteLock操作商品数量

Thread-7读取库存数据耗时:1129
Thread-3读取库存数据耗时:1130
Thread-11读取库存数据耗时:1135
Thread-15读取库存数据耗时:1135
Thread-19读取库存数据耗时:1125
Thread-23读取库存数据耗时:1124
Thread-27读取库存数据耗时:1124
Thread-31写库存数据耗时:1781
Thread-30写库存数据耗时:1826
Thread-32写库存数据耗时:1886
Thread-1读取库存数据耗时:1926
Thread-17读取库存数据耗时:1913
Thread-13读取库存数据耗时:1914
Thread-5读取库存数据耗时:1915
Thread-9读取库存数据耗时:1915
Thread-21读取库存数据耗时:1910
Thread-29读取库存数据耗时:1910
Thread-25读取库存数据耗时:1911
Thread-2读取库存数据耗时:1976
Thread-18读取库存数据耗时:1962
Thread-6读取库存数据耗时:1963
Thread-10读取库存数据耗时:1964
Thread-14读取库存数据耗时:1964
Thread-22读取库存数据耗时:1963
Thread-26读取库存数据耗时:1963
Thread-8读取库存数据耗时:2013
Thread-0读取库存数据耗时:2017
Thread-12读取库存数据耗时:2018
Thread-4读取库存数据耗时:2020
Thread-16读取库存数据耗时:2010
Thread-20读取库存数据耗时:2013
Thread-24读取库存数据耗时:2013
Thread-28读取库存数据耗时:2014

我们可以看到，使用ReentrantReadWriteLock操作商品数量比使用Synchronized高效的多，因为同一时刻允许多个读线程同时获取到读锁，这样就大大提升了读操作的效率。不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程也会一直等待释放写锁。

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

多线程篇三（Lock锁）

推荐阅读更多精彩内容