线程学习（19）-ReentrantLock基础

最新推荐文章于 2024-08-05 20:06:18 发布

前进人生

最新推荐文章于 2024-08-05 20:06:18 发布

阅读量1.3k

点赞数

分类专栏：线程文章标签：学习 java 开发语言

本文链接：https://blog.csdn.net/key_wu/article/details/125051777

版权

线程专栏收录该内容

33 篇文章 1 订阅

订阅专栏

终于写到这了，记录下ReentrantLock的特性。

ReentrantLock与Synchronized的特点比较：

ReentrantLock支持中断操作。lockInterrupte方法。

ReentrantLock锁可以设置超时时间。tryLock设置。

ReentrantLock支持公平锁。构造函数

ReentrantLock可以有多个条件变量。synchronized是waitSet,而ReentrantLock是Condition。

可重入锁

可重入锁代表当前线程如果可以已经持有了锁资源，那么他是这个锁资源的拥有者，所以可以再次获得这个锁。

不可重入锁，如果当前线程已经获取了锁资源，那么这个线程再次获取这个锁，报错。

package com.bo.threadstudy.two;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class ReentrantLockTest {
    private static final Lock lock = new ReentrantLock();

    //测试锁的可重入
    public static void main(String[] args) {
        lock.lock();
        try{
            log.debug("第一次进入");
            method1();
        }finally {
            lock.unlock();
        }



    }

    private static void method1() {
        lock.lock();
        try{
            log.debug("第二次进入");
            method2();
        }finally {
            lock.unlock();
        }

    }
    private static void method2() {
        lock.lock();
        try{
            log.debug("第三次进入");
            method3();
        }finally {
            lock.unlock();
        }
    }

    private static void method3() {
        lock.lock();
        try{
            log.debug("第四次进入");
        }finally {
            lock.unlock();
        }
    }

}

可中断锁

这个依赖于ReentrantLock中的lockInterruptibly()方法。

A,B两个线程，A加锁情况下，B试图获取该锁但获取不到资源，在A线程中可以通过打断操作，在B线程抛出打断异常，进而可以在结束线程。而B线程使用lock方法时，抛出打断异常时。Exception 'java.lang.InterruptedException' is never thrown in the corresponding try block，不支持该方法抛出该异常，没有入口去得到当前线程的打断状态做后续操作。

使用debug看一下，如果B线程采用lock()方法进行加锁，interrupt方法打断后当前线程的状态还是Wait,如果通过lockInterroptibly方法来进行加锁时，interrupt方法打断后状态为Running。

Synchronized不可打断也是同样的道理，在竞争锁资源的时候，A线程在运行时执行了interrupt（），B线程在Idea中一直都是Monitor状态（Blocked）状态。依旧在阻塞。

原先学的，调用wait()方法后，在其余线程中打断该线程是可以打断的，但现在有个情况，执行wait()方法后，锁资源已经释放了，不存在竞争关系。所以线程可以被打断。这里的中断锁，前提是竞争锁的条件下（打断Blocked状态线程）是否可以打断。

package com.bo.threadstudy.four;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试ReetentLock可中断
 * 这里的可中断，在我的理解中，是可以中断正在阻塞的线程，试试
 */
@Slf4j
public class InterruptreentrantLockTest {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
            try {
                //可中断的锁
                log.debug("开始加锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("等待锁的过程被打断");
                return;
            }
            try {
                log.debug("加锁完成");
            } finally {
                lock.unlock();
                log.debug("解锁完成");
            }
        }, "t1");

        lock.lock();
        log.debug("主线程获取了锁");
        t1.start();

        //保证t1线程可以获取锁
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打断t1线程
        try {
            t1.interrupt();
            log.debug("执行打断");
        } finally {
            lock.unlock();
        }
    }

}

//synchronized不可中断锁，试试
@Slf4j
class InterruptSynchronizedTest {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
            //可中断的锁
            log.debug("开始加锁");
            synchronized (InterruptSynchronizedTest.class) {
                log.debug("加锁完成");
            }
            log.debug("解锁完成");
        }, "t1");

        synchronized (InterruptSynchronizedTest.class){
            t1.start();
            //保证t1线程可以获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            t1.interrupt();

            //这样，主线程不释放锁，t1线程是永远无法结束的，一直在等待
            try {
                while(true){
                    Thread.sleep(1000);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("执行打断");

        }
    }
}

锁超时

基于tryLock方法来实现，来实现对reetrantLock锁的超时操作。方法为试图获取锁，返回true或false。不加参数表示立刻获取，加上参数表示过多长时间来获取。

package com.bo.threadstudy.four;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 锁超时测试
 */
@Slf4j
public class TryLockTest {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        new Thread(() -> {
            if(lock.tryLock()){
                try{
                    log.debug("t1已获取到锁");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }else{
                log.debug("t1没有获取到锁");
            }
        },"t1").start();


        new Thread(() -> {
            try {
                if(lock.tryLock(3, TimeUnit.SECONDS)){
                    try{
                        log.debug("t2已获取到锁");
                    }finally {
                        lock.unlock();
                    }
                }else{
                    log.debug("t2没有获取到锁");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }

}

使用tryLock解决哲学家就餐问题

我原先采用synchronized的方式来解决时，是通过条件判定，单编号哲学家先吃饭，双编号哲学家后吃饭，那么现在采用tryLock的方式解决一下。

package com.bo.threadstudy.four;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 哲学家就餐问题，使用trylock方式解决
 */
@Slf4j
public class TrylockEatTest {
    public static void main(String[] args) {
        PhilosopherTry t1 = new PhilosopherTry("亚里士多德", 1, 2);
        PhilosopherTry t2 = new PhilosopherTry("柏拉图", 2, 3);
        PhilosopherTry t3 = new PhilosopherTry("苏格拉底", 3, 4);
        PhilosopherTry t4 = new PhilosopherTry("但丁", 4, 5);
        PhilosopherTry t5 = new PhilosopherTry("拿破仑", 5, 1);
        ArrayList<PhilosopherTry> philosophers = new ArrayList<>();
        philosophers.add(t1);
        philosophers.add(t2);
        philosophers.add(t3);
        philosophers.add(t4);
        philosophers.add(t5);

        for (PhilosopherTry philosopher : philosophers) {
            new Thread(() -> {
                philosopher.eat();
            },philosopher.getName()).start();
        }

    }
}

/**
 * 哲学家类
 */
@Slf4j
class PhilosopherTry{
    //姓名
    private String name;
    //肯定是需要一双筷子的
    private ChopsticksTry leftChopstick;

    private ChopsticksTry rightChopstick;

    public String getName() {
        return name;
    }

    PhilosopherTry(String name, Integer left, Integer right){
        this.name = name;
        leftChopstick = new ChopsticksTry();
        rightChopstick =  new ChopsticksTry();
    }

    //吃饭操作
    public void eat(){
        try{
            if(leftChopstick.tryLock()){
                log.debug(name+"已获取左手的筷子");
                if(rightChopstick.tryLock()){
                    try{
                        log.debug(name+"已获取右手的筷子");
                    }finally {
                        //释放右手的筷子
                        rightChopstick.unlock();
                        log.debug(name+"放下右手的筷子");
                    }
                }else{
                    log.debug(name+"没获取右手筷子，放下左手的筷子");
                }
            }else{
                log.debug(name+"没获取左手筷子");
            }
        } finally {
            //释放左手筷子
            log.debug(name+"放下左手筷子");
            leftChopstick.unlock();
        }

    }
}

/**
 * 筷子类
 */
class ChopsticksTry extends ReentrantLock{
    private Integer id;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

公平锁

公平锁，指的是锁竞争的时候是否公平，因为ReentrantLock是依赖于底层的AQS来进行排队等待的，类似于synchronized锁的entryList。公平锁的方式，线程在获取锁资源时会判断AQS队列是否有等待线程，如果有等待线程，则将竞争锁的线程加到阻塞队列之中。如果是非公平锁，在竞争锁资源的时候是不会判断AQS内部是否存在其它线程，而是先竞争，竞争成功获取锁资源，竞争失败则加入到AQS中。

ReentrantLock默认情况下是非公平锁，可以通过构造函数指定判断其是否是公平锁。但会降低线程并发度，不建议使用。

结果并不准确。

package com.bo.threadstudy.four;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试ReentrantLock公平锁
 */
@Slf4j
public class FaairLockTest {

    private static ReentrantLock lock = new ReentrantLock(false);

    public static void main(String[] args) {
        for (int i = 0; i < 500; i++) {
            int finalI = i;
            new Thread(() -> {
                lock.lock();
                try{
                    log.debug("线程正在行走"+ finalI);
                }finally {
                    lock.unlock();
                }

            },"t"+i).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try{
            log.debug("测试暴力插入");
        }finally {
            lock.unlock();
        }


    }

}

条件变量Condition

这个依赖于ReentrantLock中的newCondition()方法，与Synchronized中的waitSet有点类似。只不过不同的点在于，Condition这个条件变量，一个Reentrant支持多个。

synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待
ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比
synchronized 是那些不满足条件的线程都在一间休息室等消息
而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤
醒
使用要点：
await 前需要获得锁
await 执行后，会释放锁，进入 conditionObject 等待
await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
竞争 lock 锁成功后，从 await 后继续执行

简单写一个样例。

package com.bo.threadstudy.four;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试wait系列的condition
 */
@Slf4j
public class ConditionTest {
    private static ReentrantLock  lock = new ReentrantLock();
    private static Condition condition;

    public static void main(String[] args) throws InterruptedException {
        condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try{
                log.debug("测试代码运行顺序1");
                condition.await();
                log.debug("结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        },"t1").start();

        Thread.sleep(1000);
        new Thread(() -> {
            lock.lock();
            try{
                log.debug("测试代码运行顺序2");
                condition.signal();
            }finally {
                lock.unlock();
            }
        },"t2").start();

    }

}