【多线程：ReentrantLock】

01.介绍

RennttrantLock也是锁和synchronized一样具有锁定同步代码块的作用，不过和synchronized还是有很多不一样的地方。
RennttrantLock是java.util.concurrent(juc) 下的一个类，相对于synchronized它具备如下特点：

1.可以打断处于BLOCKED状态的其他线程
2.可以设置处于BLOCKED状态的线程超时时间，如果超过这个时间就放弃争抢锁
3.可以设置为公平锁，线程按照先入先出获取锁
4.支持多个条件变量，这个是指对于等待区我们可以由多个不同对象调用锁处于等待状态时所在的等待区不同，对于synchronized锁来说它的等待区就只有一个WaitSet

与synchronized一样都支持锁重入，即自己可以再次获取自己内部的锁

02.基本语法

    ReentrantLock lock = new ReentrantLock();
    lock.lock();
    try{
        // lock.lock();
        // 临界区
    }finally{
        // 释放锁
        lock.unlock();
    }

注意：lock.lock();可以放在try外面，也可以放在try里面，最后在finally中需要进行lock.unlock();释放锁

03.可锁重入

例子

public class TestInterKCR {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        lock.lock();
        try {
            System.out.println("enter main");
            m1();
        }finally {
            lock.unlock();
        }
    }
    private static void m1(){
        lock.lock();
        try {
            System.out.println("enter m1");
            m2();
        }finally {
            lock.unlock();
        }
    }

    private static void m2(){
        lock.lock();
        try {
            System.out.println("enter m2");
        }finally {
            lock.unlock();
        }
    }
}

结果

enter main
enter m1
enter m2

解释
可以看出自己内部的锁都可以调用，没有发生死锁，说明可以锁重入

04.可打断

介绍

我们先要明确一个概念，这里说的可打断说的是一个已经获得锁的线程t1 和一个处于阻塞状态线程的t2(因为t1已经获取了锁)，我们可以在其他线程中把 t2线程打断使之跳出阻塞状态运行其它部分代码。

synchronized为什么不可以打断

例子

public class TestInterSync {
    private static String a = "s";
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            System.out.println("t1尝试获取锁");
            synchronized (a){
                System.out.println("t1获取到锁");
                    boolean interrupted = Thread.currentThread().isInterrupted();
                    if (interrupted){
                        System.out.println("t1被打断");
                    }
            }
        });

        Thread t2 = new Thread(()->{
            System.out.println("t2尝试获取锁");
            synchronized (a){
                System.out.println("t2获取到锁");
                while (true){

                }
            }
        });
        t2.start();
        Sleeper.sleep(0.5);
        t1.start();
        Sleeper.sleep(0.5);
        System.out.println("打断正在等待锁的t1线程");
        t1.interrupt();
    }

}

结果

程序没有结束：
t2尝试获取锁
t2获取到锁
t1尝试获取锁
打断正在等待锁的t1线程

解释
我们发现程序并没有结束，我们的t2线程先获取到锁且没有释放锁，导致t1线程阻塞，现在我们在主线程中打断t1线程但是发现无法打断

lock方法可以打断吗？

例子

public class TestInterReenY {
        private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{

            System.out.println("t1尝试获取锁");
            lock.lock();
            try {
                System.out.println("t1获取到锁");
            }finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(()->{
            System.out.println("t2尝试获取锁");
            lock.lock();
            try {
                System.out.println("t2获取到锁");
                Sleeper.sleep(2);
            }finally {
            }
        });
        t2.start();
        Sleeper.sleep(0.5);
        t1.start();
        Sleeper.sleep(0.5);
        System.out.println("打断正在等待锁的t1线程");
        t1.interrupt();
    }

}

结果

程序没有结束：
t2尝试获取锁
t2获取到锁
t1尝试获取锁
打断正在等待锁的t1线程

解释
我们发现lock方法依然不能打断处于阻塞状态的线程，那我们应该用什么，答案是lockInterruptibly方法

lockInterruptibly方法

例子

public class TestInterReen {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            try {
                System.out.println("t1尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("t1被打断");
                return;
            }

            try {
                System.out.println("t1获取到锁");
            }finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(()->{
            try {
                System.out.println("t2尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("t2被打断");
                return;
            }
            try {
                System.out.println("t2获取到锁");
                Sleeper.sleep(2);
            }finally {
            }
        });
        t2.start();
        Sleeper.sleep(0.5);
        t1.start();
        Sleeper.sleep(0.5);
        System.out.println("打断正在等待锁的t1线程");
        t1.interrupt();
    }

}

结果

程序结束：
t2尝试获取锁
t2获取到锁
t1尝试获取锁
打断正在等待锁的t1线程
t1被打断

解释
可以看出我们用lockInterruptibly方法可以实现打断处于阻塞状态的线程

05.锁超时

介绍

锁超时是指，一旦锁被其他线程占用如果没有指定超时时间则本线程会直接跳出阻塞状态不参与竞争，如果指定了超时时间则超时时间内处于阻塞状态超出超时时间则跳出阻塞状态。

例子：无时限

@Slf4j(topic = "c.TestInterCS")
public class TestInterCS {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            log.debug("t1尝试获取锁");
            if (!lock.tryLock()){
                    log.debug("t1获取不到锁");
                    return;
            }

            try {
                log.debug("t1获取到锁");
            }finally {
            }
        },"t1");

        Thread t2 = new Thread(()->{
            log.debug("t2尝试获取锁");
            if (!lock.tryLock()){
                log.debug("t2获取不到锁");
                return;
            }

            try {
                log.debug("获取到锁");
            }finally {
                lock.unlock();
            }
        },"t2");
        t1.start();
        Sleeper.sleep(1);
        t2.start();
    }
}

结果

00:40:27.595 c.TestInterCS [t1] - t1尝试获取锁
00:40:27.597 c.TestInterCS [t1] - t1获取到锁
00:40:28.600 c.TestInterCS [t2] - t2尝试获取锁
00:40:28.600 c.TestInterCS [t2] - t2获取不到锁

解释
可以看出t1线程获取到锁并且没有释放，t2线程一直处于阻塞状态，我们用tryLock方法且没有指定超时时间也就是一旦发现t2线程处于阻塞状态lock.tryLock()返回false，我们执行其它代码

例子：有时限

@Slf4j(topic = "c.TestInterCS")
public class TestInterCS {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            log.debug("t1尝试获取锁");
            try {
                if (!lock.tryLock(2, TimeUnit.SECONDS)){
                    log.debug("t1获取不到锁");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.debug("t1获取到锁");
            }finally {
            }
        },"t1");

        Thread t2 = new Thread(()->{
            log.debug("t2尝试获取锁");
            if (!lock.tryLock()){
                log.debug("t2获取不到锁");
                return;
            }

            try {
                log.debug("获取到锁");
            }finally {
                lock.unlock();
            }
        },"t2");
        t1.start();
        Sleeper.sleep(1);
        t2.start();
    }
}

结果

00:44:46.180 c.TestInterCS [t1] - t1尝试获取锁
00:44:46.183 c.TestInterCS [t1] - t1获取到锁
00:44:47.183 c.TestInterCS [t2] - t2尝试获取锁
00:44:47.183 c.TestInterCS [t2] - t2获取不到锁

解释
我们给tryLock方法指定时间为2s，但是因为t1线程始终没有释放锁，所以结果lock.tryLock()依然返回false，我们进行逻辑判断，执行其它的代码

哲学家就餐问题

介绍
之前我们介绍过哲学家就餐问题，当时我们用顺序加锁的方法解决了死锁的问题，但是当时产生了饥饿问题，这次我们用锁超时解决饥饿问题
代码

@Slf4j(topic = "c.Test23")
public class Test23 {public static void main(String[] args) {
    Chopstick c1 = new Chopstick("1");
    Chopstick c2 = new Chopstick("2");
    Chopstick c3 = new Chopstick("3");
    Chopstick c4 = new Chopstick("4");
    Chopstick c5 = new Chopstick("5");
    new Philosopher("苏格拉底", c1, c2).start();
    new Philosopher("柏拉图", c2, c3).start();
    new Philosopher("亚里士多德", c3, c4).start();
    new Philosopher("赫拉克利特", c4, c5).start();
    new Philosopher("阿基米德", c5, c1).start();
}
}

@Slf4j(topic = "c.Philosopher")
class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            //　尝试获得左手筷子
            if(left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if(right.tryLock()) {
                        try {
                            eat();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock(); // 释放自己手里的筷子
                }
            }
        }
    }

    Random random = new Random();
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(0.5);
    }
}

class Chopstick extends ReentrantLock {
    String name;

    public Chopstick(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

结果

.
.
.
00:54:18.866 c.Philosopher [苏格拉底] - eating...
00:54:18.866 c.Philosopher [亚里士多德] - eating...
00:54:19.373 c.Philosopher [柏拉图] - eating...
00:54:19.373 c.Philosopher [阿基米德] - eating...
00:54:19.881 c.Philosopher [苏格拉底] - eating...
00:54:19.881 c.Philosopher [赫拉克利特] - eating...
00:54:20.386 c.Philosopher [苏格拉底] - eating...
00:54:20.386 c.Philosopher [亚里士多德] - eating...
00:54:20.894 c.Philosopher [亚里士多德] - eating...
00:54:20.894 c.Philosopher [苏格拉底] - eating...
00:54:21.401 c.Philosopher [赫拉克利特] - eating...
00:54:21.401 c.Philosopher [柏拉图] - eating...
00:54:21.908 c.Philosopher [苏格拉底] - eating...
00:54:21.908 c.Philosopher [赫拉克利特] - eating...
00:54:22.417 c.Philosopher [苏格拉底] - eating...
00:54:22.417 c.Philosopher [赫拉克利特] - eating...
.
.
.
.

解释
我们可以看出现在没有产生死锁且也没有线程处于饥饿，这里的做法是让Chopstick继承ReentrantLock类，然后Chopstick对象也就是筷子使用tryLock方法如果和其他哲学家产生竞争就放弃获取，这样自然而然没有了由于互相争抢而产生的死锁问题了

06.公平锁

介绍
多个线程按照申请锁的顺序获取锁
源码

可以看出，ReentrantLock有参构造传递的为true则创建出的对象就为公平锁(默认是不公平锁)，公平锁一般没有必要会降低并发度，之后我们学习AQS时会分析它的源码

07.条件变量

介绍

synchronized中也有条件变量，就是我们讲原理时Monitor中的WaitSet，当条件不满足时进入WaitSet中等待。
ReentrantLock的条件变量比synchronized强大之处在于它是之处多个条件变量的这就好比 synchronized是那些不满足条件的线程都在一间休息室等消息，而ReentrantLock支持多间休息室有专门等烟条件的休息室有专门等待早餐条件的休息室唤醒时也是按照休息室来唤醒

使用流程

1.await前需要获取锁
2.await执行后会释放锁进入conditionObject等待
3.await的线程被唤醒(或打断或超时)去重新竞争lock锁
4.竞争lock锁成功后从await后继续执行

例子

还是之前那个wait/notify的例子，这次使用RenntrantLock实现

@Slf4j(topic = "c.Test24")
public class Test24 {
    static final Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;
    static ReentrantLock ROOM = new ReentrantLock();
    // 等待烟的休息室
    static Condition waitCigaretteSet = ROOM.newCondition();
    // 等外卖的休息室
    static Condition waitTakeoutSet = ROOM.newCondition();

    public static void main(String[] args) {


        new Thread(() -> {
            ROOM.lock();
            try {
                log.debug("有烟没？[{}]", hasCigarette);
                while (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        waitCigaretteSet.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("可以开始干活了");
            } finally {
                ROOM.unlock();
            }
        }, "小南").start();

        new Thread(() -> {
            ROOM.lock();
            try {
                log.debug("外卖送到没？[{}]", hasTakeout);
                while (!hasTakeout) {
                    log.debug("没外卖，先歇会！");
                    try {
                        waitTakeoutSet.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("可以开始干活了");
            } finally {
                ROOM.unlock();
            }
        }, "小女").start();

        sleep(1);
        new Thread(() -> {
            ROOM.lock();
            try {
                hasTakeout = true;
                waitTakeoutSet.signal();
            } finally {
                ROOM.unlock();
            }
        }, "送外卖的").start();

        sleep(1);

        new Thread(() -> {
            ROOM.lock();
            try {
                hasCigarette = true;
                waitCigaretteSet.signal();
            } finally {
                ROOM.unlock();
            }
        }, "送烟的").start();
    }

}

结果

01:20:49.292 c.Test24 [小南] - 有烟没？[false]
01:20:49.295 c.Test24 [小南] - 没烟，先歇会！
01:20:49.295 c.Test24 [小女] - 外卖送到没？[false]
01:20:49.295 c.Test24 [小女] - 没外卖，先歇会！
01:20:50.300 c.Test24 [小女] - 可以开始干活了
01:20:51.309 c.Test24 [小南] - 可以开始干活了

解释
我们创建了两个休息室，小南在没有获得烟这个条件前进入的是waitCigaretteSet休息室，小女在没有获得外卖这个条件前进入的是waitTakeoutSet这个休息室，相比于之前使用synchronized时小女和小南没有获得条件之前进入的都是WaitSet，这里更加细分了。后面唤醒时也是按照休息区来唤醒。

【多线程：ReentrantLock】

【多线程：ReentrantLock】

01.介绍

02.基本语法

03.可锁重入

04.可打断

介绍

synchronized为什么不可以打断

lock方法可以打断吗？

lockInterruptibly方法

05.锁超时

介绍

例子：无时限

例子：有时限

哲学家就餐问题

06.公平锁

07.条件变量

介绍

使用流程

例子

热门文章

最新文章

相关电子书