java多线程JUC库分析之ReentrantLock

锁的应用

  1. 锁能够解决并发共抢资源的问题,例子如下

public class Test {

    private static int sum;


    public static void main(String[] args) {

        for (int i = 0; i< 100; i++){
            Thread t = new Thread(new Calc());
            t.start();
        }
        try{
            Thread.sleep(1000);
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(sum);
    }

    static class Calc implements Runnable {

        @Override
        public void run() {

            sum++;

            System.out.println(Thread.currentThread().getName() +":"+ sum);
        }
    }
}

启动100个线程对sum进行累加,结果不一定是100,优化,加锁后问题解决


public class Test {

    private static volatile int sum;
    private static ReentrantLock lock;

    public static void main(String[] args) {
        lock = new ReentrantLock();
        for (int i = 0; i< 100; i++){
            Thread t = new Thread(new Calc());
            t.start();
        }
        try{
            Thread.sleep(1000);
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(sum);
    }

    static class Calc implements Runnable {

        @Override
        public void run() {
            lock.lock();
            sum++;
            lock.unlock();
            System.out.println(Thread.currentThread().getName() +":"+ sum);
        }
    }
}

题外话:上述例子还有一个细节就是,volatile ,没有volatile ,不影响最终结果,但是线程打印的值有重复。这里验证类volatile的可见性,一个线程修改,其他线程立即可见。
image.png

  1. 锁的Condition,condition是条件,用于共同完成一项作业,需要协作的场景。
    例子,产生随机数,打印随机数,先产生后打印

public class Test {

    private static int random;
    private static ReentrantLock lock;
    private static Condition condition;

    public static void main(String[] args) throws Exception {
        lock = new ReentrantLock();
        condition = lock.newCondition();
        new Thread(new Print()).start();
        Thread.sleep(1000);
        new Thread(new Generator()).start();
        System.out.println("main exit.");
    }

    static class Print implements Runnable {
        @Override
        public void run() {
            lock.lock();
            try {
                System.out.println("Print await.");
                condition.await();
                System.out.println("Print start.");
                System.out.println("result is : " + random);

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("Print unlock.");
                lock.unlock();
            }
        }
    }

    static class Generator implements Runnable {

        @Override
        public void run() {
            lock.lock();
            try {
                System.out.println("generator start.");
                random = (int) (Math.random() * 10000);
                System.out.println("generator before signal.");
                condition.signal();
                System.out.println("generator after signal.");
            } finally {
                System.out.println("generator unlock.");
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                lock.unlock();

            }
        }
    }
}

锁的实现

  1. LockSupport类介绍
    LockSupport在实现锁的时候,用于挂起和唤醒线程;多线程竞争,只有一个线程获取到锁继续运行,其他线程挂起,待锁释放后,处于队里最前面等待的线程被唤醒,被唤醒不意味着马上获取到锁,而是马上快速尝试取锁。挂起和唤醒的衔接是LockSupport。
public class Test {

    private static volatile int sum;
    private static ReentrantLock lock;

    static class Park implements Runnable {
        @Override
        public void run() {
            park();
        }
        void park() {
            System.out.println("park");
            LockSupport.park(this);
            System.out.println("out park");
        }
    }
    public static void main(String[] args) {
        Thread t = new Thread(new Park());
        t.start();
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        LockSupport.unpark(t);
    }
}

上述演示了LockSupport park和unpark的使用,线程在park处被挂起,直到被其他线程唤醒,唤醒之后从park的下一行代码继续执行。上述例子,是被主线程唤醒。

jstack命令查看
主线程信息
image.png

被park的线程信息,名称是Thread-0,
image.png

park()和 park(Object blocker)的主要区别是,后者把阻塞信息打印更详细一些,如上图的 “- parking to wait for xxxxx”。blocker是否还有其他用处,待考察。

重要关注点:
看JDK LockSupport.park的方法注释,可以知道,park方法响应线程interrupt,就说,线程被interrupt,会被唤醒。线程被interrupt唤醒后,会把它在等待锁队列Node状态设置成Cancel 1.

唤醒特殊情况下会从tail往前遍历原因:
线程释放锁后,调用unparkSuccessor,如果遇到被取消的Node,需要从tail往前遍历。因为如果阻塞队列有多个等待的线程。在锁释放的一瞬间,如果出现unparkSuccessor和等待线程被interrupt并发情形,那么从head往下遍历,不一定能够遍历到有效节点;但是,从tail遍历肯定能够得到有效节点。
为什么从head遍历不一定能够找到有效节点,因为AQS的cancelAcquire会把cancle节点的next设置成,node.next = node;

AQS模板设计模式:AQS提供aquire和release 模板方法供子类调用,模板方法中的tryRequire 和tryRelease 供子类调用定制自身逻辑

  1. ReentrantLock重入锁的实现
    重入锁涉及到主要类关系图和lock方法调用图
    image.png

线程抢占锁、释放锁唤醒同步器队列线程,以及同步器的成员变量head,tail,state变化详细过程如下,用3个线程抢占一把锁开始运行到结束的一次运行过程。

image.png

从上述看,可知,假如在线程1释放锁,在唤醒线程2之前,突然有个线程4抢占到锁。这时线程2醒了之后是抢不到锁的。这种谁先抢到是谁的,称之为“不公平锁”,重入锁还支持“公平锁”,公平锁就是谁等待最久,那么优先给谁。具体实现可以看源码,默认的重入锁是“不公平锁”。从效率上来看,“不公平锁”效率高一些。

  1. ReentrantLock重入锁的Condition实现

    Condition条件队列,一个线程只有先获取lock 才能进入执行condition.await, await动作把线程放到条件队列,然后把lock释放掉,进入park让出cpu。
    condition.signal,把条件队列的线程放入同步队列,然后释放lock,unpark同步队列上的线程。

condition不能单独使用,必须配合lock使用,事实上,condition出现是为了多线程协调配合工作需要,比如,生产者消费者模式,消费者线程的输入是生产者线程的输出,因此两个线程运行是有条件的,需要协调的。如果两个线程互相独立,那么就不需要用锁和condition了。那么为什么condition必须要lock配合,因为生产者和消费者,不能同时运行,因此需要锁,只有获取锁的一方可以运行。生产者获取锁后,生产出东西,释放锁。让消费者去消费。这种场景用lock lock可以,但是消费者消费完后,如何让生产者接着生存,这就需要通知,condition就是这样应运而生的。

如下是消费者和生产者一次交互过程

image.png

需要说明序号并不是严格是运行顺序,比如4释放锁后,5和6是并行的,不能确定谁先谁后。

评论

暂无评论