Java并发之ReentrantLock

最新推荐文章于 2020-12-22 22:59:24 发布
最新推荐文章于 2020-12-22 22:59:24 发布
阅读量256 收藏
点赞数
分类专栏： Java 文章标签： Java 并发

在Java中通常实现锁有两种方式，一种是synchronized关键字，另一种是Lock。二者其实并没有什么必然联系，但是各有各的特点，在使用中可以进行取舍的使用。具体的区别本文就不讲了，主要讲讲Lock的实现类ReentrantLock。

1、简介

ReentrantLock是基于AQS（AbstractQueuedSynchronized）来实现的。

阅读本文之前还需要了解几个概念：

  1. 可重入锁：指的是同一线程外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码。也就是同一线程可以获得多个锁。不然就会发生死锁问题。
  2. 可中断锁：在某些条件下可以相应中断的锁。在Java中，synchronized就不是可中断锁，而 Lock是可中断锁。
  3. 公平锁：公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。
  4. 非公平锁：无法保证锁的获取是按照请求锁的顺序进行的。有可能锁刚被释放，正好新来了个线程请求锁，这样后面等待的线程就不能获得锁。在极端情况下，可能导致一直无法获取锁。

2、框架

ReentrantLock中提供了一个Sync类重写了AQS的几个重要方法，并且基于Sync提供了FairSync和NonfairSync两个类。

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可以通过构造函数看到，默认使用的是非公平锁，当然我们也可以通过参数指定使用哪个类。

在ReentrantLock中，我们最常用的也就两个方法：lock和unlock，其他方法本文就不说了。

3、源码分析

3.1、Sync

3.1.1、FairSync和NonfairSync

static final class FairSync extends ReentrantLock.Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

实现公平性的主要就是hasQueuedPredecessors() 这个方法，它用来返回队列中是否有比当前线程等待更久的线程。这也是和下面说的NonfairSync的唯一区别的地方。

下面举一个公平锁和非公平锁的例子

public class FairAndUnfairTest {
    private static Lock fairLock = new ReentrantLock2(true);
    private static Lock unfairLock = new ReentrantLock2(false);

    private void testLock(Lock lock) {
        for (int i = 0; i < 5; i++) {
            Job job = new Job(lock);
            job.setName("线程" + (i + 1));
            job.start();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FairAndUnfairTest test = new FairAndUnfairTest();
//        test.testLock(fairLock);
        test.testLock(unfairLock);
    }

    private static class Job extends Thread {
        private Lock lock;
        public Job(Lock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            for (int i = 0; i < 2; i++) {
                lock.lock();
                try {
                    Collection<Thread> threads = ((ReentrantLock2)lock).getQueuedThreads();
                    Thread.sleep(1000);
                    System.out.println("获取锁的当前线程[" + Thread.currentThread().getName() + "], 同步队列中的线程" + getThreadName(threads));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    private static String getThreadName(Collection<Thread> threads) {
        StringBuilder sb = new StringBuilder();
        if (threads != null) {
            for (Thread thread : threads) {
                sb.append(thread.getName()).append(",");
            }
        }
        String waitingThreads = null;
        if (sb.length() > 0) {
            waitingThreads = sb.substring(0, sb.length() - 1);
        }
        return waitingThreads;
    }

    private static class ReentrantLock2 extends ReentrantLock {
        public ReentrantLock2(boolean fair) {
            super(fair);
        }

        @Override
        public Collection<Thread> getQueuedThreads() {
            List<Thread> arrayList = new ArrayList<>(super.getQueuedThreads());
            Collections.reverse(arrayList);
            return arrayList;
        }
    }
}

输出结果为：

// 打开test.testLock(fairLock)的输出结果
获取锁的当前线程[线程1], 同步队列中的线程null
获取锁的当前线程[线程2], 同步队列中的线程线程3,线程4,线程5,线程1
获取锁的当前线程[线程3], 同步队列中的线程线程4,线程5,线程1,线程2
获取锁的当前线程[线程4], 同步队列中的线程线程5,线程1,线程2,线程3
获取锁的当前线程[线程5], 同步队列中的线程线程1,线程2,线程3,线程4
获取锁的当前线程[线程1], 同步队列中的线程线程2,线程3,线程4,线程5
获取锁的当前线程[线程2], 同步队列中的线程线程3,线程4,线程5
获取锁的当前线程[线程3], 同步队列中的线程线程4,线程5
获取锁的当前线程[线程4], 同步队列中的线程线程5
获取锁的当前线程[线程5], 同步队列中的线程null

// 打开test.testLock(unfairLock)的输出结果
获取锁的当前线程[线程1], 同步队列中的线程null
获取锁的当前线程[线程1], 同步队列中的线程线程2,线程3,线程4,线程5
获取锁的当前线程[线程2], 同步队列中的线程线程3,线程4,线程5
获取锁的当前线程[线程2], 同步队列中的线程线程3,线程4,线程5
获取锁的当前线程[线程3], 同步队列中的线程线程4,线程5
获取锁的当前线程[线程3], 同步队列中的线程线程4,线程5
获取锁的当前线程[线程4], 同步队列中的线程线程5
获取锁的当前线程[线程4], 同步队列中的线程线程5
获取锁的当前线程[线程5], 同步队列中的线程null
获取锁的当前线程[线程5], 同步队列中的线程null

显然，试验结果与我们的预期相符。在以非公平锁的方式获取锁，当一个线程在获取锁又释放锁，但又立即获取锁的时候，这个时候这个线程有很大的概率会成功（只是很大概率，试验结果也有可能不连续两次获取锁）。而公平锁则不一样，哪怕是同一个线程连续两次获取锁和释放锁，在第一次获取锁释放锁过后接着准备第二次获取锁时，这个时候当前线程会被加入到同步队列的队尾。

那么，公平锁和非公平锁的性能谁高谁低呢？上面的例子我们可以发现非公平锁的一个线程连续两次获取锁和释放锁的工程中，是没有做上下文切换的，也就是一共只做了5次上下文切换。而公平锁实际上做了10次上下文切换。性能测试的例子可以参考：【试验局】ReentrantLock中非公平锁与公平锁的性能测试

结论：非公平锁的性能因其系统上下文的切换较少，其性能一般要优于公平锁。

3.1.2、lock()

public void lock() {
    sync.lock();
}

lock方法很简单，直接调用的AQS的lock方法。sync的lock方法会根据公平性选择不同的lock方法，上面我们看过了FairSync和NonfairSync类，再来重温一下它的方法。

// NonfairSync
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

// FairSync
final void lock() {
    acquire(1);
}

NonfairSync会判断当前是否有线程持有锁，如果没有，直接获得锁返回。不然会和公平锁一样去调AQS的acquire方法

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

首先会用tryAcquire方法来判断是否能够获取锁，这个方法也在FairSync和NonfairSync中进行了重写。

/**
 * FairSync
 * 获取公平锁
 * 1. 当前无锁，并且没有等待更久的线程的话，给当前线程上锁
 * 2. 当前有锁，但是加锁的线程是当前线程，增加状态值
 * 其他情况返回false
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

/**
 * NonfairSync
 * 获取非公平锁
 * 1. 当前无锁，给当前线程上锁
 * 2. 当前有锁，但是加锁的线程是当前线程，增加状态值
 * 其他情况返回false
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

这两个方法只有一个hasQueuedPredecessors 方法不同，上面已经说过了，这里就不赘述了。

3.1.3、unlock()

public void unlock() {
    sync.release(1);
}

和lock一样，unlock也是调用的AQS的release方法，所以我们直接看tryRelease的实现就行。因为该方法公平性和非公平性是一样的，所以直接看Sync里的tryRelease()方法。

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;    // 释放state
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {    // 释放成功，返回true
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

方法很简单，先释放状态，再判断状态是不是0，0的话意味着该线程所有的锁都释放了，返回true，唤醒Sync队列后面的线程来争夺锁。

3.1.4、其他方法解释

  • getHoldCount()：查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
  • getQueueLength()：返回正等待获取此锁定的线程估计数
  • getWaitQueueLength()：返回等待与此锁定相关的给定条件Condition的线程估计数。比如有5个线程，每个线程都执行了同一个condition对象的await方法，则调用getWaitQueueLength(Condition condition)方法时返回5
  • hasQueuedThread(Thread thread)：查询指定的线程是否正在等待获取此锁定。
  • hasQueueThreads()：查询是否有线程正在等待获取此锁定。
  • hasWaiters(Condition condition)：查询是否有线程正在等待与此锁定有关的condition条件。
  • isFair()：判断是不是公平锁
  • isHeldByCurrentThread()：查询当前线程是否保持此锁定
  • isLocked()：查询此锁定是否由任意线程保持。
  • lockInterruptibly()：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常。
  • tryLock()：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定。
  • tryLock(long timeout, TimeUnit unit)：如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定。
  • awaitUninterruptibly()：只有当不被中断的时候await，一旦发生中断，不会抛出异常，会直接结束。
  • awaitUntil()：等待到指定时间停止等待，期间可以被其他线程提前唤醒。

3.1.5、小结

ReentrantLock里的方法实现要结合AQS来看，主要方法和原理都在AQS中，ReentrantLock只是做了一个简单的实现而已。

4、使用

我们可以使用Lock来实现的生产消费。

public class ProducerConsumerTest {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean hasValue = false;

    public void produce() {
        try {
            lock.lock();
            while (hasValue) {
                condition.await();
            }
            System.out.println("生产");
            hasValue = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() {
        try {
            lock.lock();
            while (!hasValue) {
                condition.await();
            }
            System.out.println("消费");
            hasValue = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final ProducerConsumerTest producerConsumerTest = new ProducerConsumerTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    producerConsumerTest.produce();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    producerConsumerTest.consume();
                }
            }
        }).start();
    }
}


as98765
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java ReentrantLock
weixin_35821291的博客
03-23 4934
1. 锁的意义——线程同步 2. 案例——基于ReentrantLock来实现同步 public class A { public static ReentrantLock reentrantLock = new ReentrantLock(); public static void main(String[] args) { new Thread(() -> { testSync(); }, "t1").start()
Java中的ReentrantLock详解
最新发布
weixin_33997566的博客
07-15 42
Java中的ReentrantLock详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在Java编程中，多线程同步是一个常见的需求。为了保证多个线程对共享资源的安全访问，Java提供了多种锁机制，其中ReentrantLock是一个重要的工具。本文将详细介绍ReentrantLock的...
java之ReentrantLock
mmoren的博客
03-26 235
Lock接口Synchronized属于隐式锁，即锁的释放和获取都是隐式的。而我们接下来介绍的是显示锁Lock。JDK1.5中，在JAVA JUC包中添加了Lock接口，该接口提供了lock（）方法和unlock（）方法，以支持显示的加锁和解锁。需要注意的是unlock方法需要在finally中实现，不然会因为异常的出现导致各种并发问题。public interface Lock { //...
【Java】ReentrantLock
u010900754的专栏
08-24 288
基本上都把这个锁叫做重入锁，其实这样叫是字面理解，但是无法区分与synchronized的区别，从实现来讲，叫做显式锁更好，因为ReentrantLock的加锁是显示的，而synchronized则是内置的，所以应该是内置锁。 显式锁的特性 首先看下显式锁的使用，打开源码，有一段注释： public void m() { * lock.lock(); // block until
java中的ReentrantLock
峰哥的专栏
03-04 2000
ReentrantLock是JDK5加入的新类，它的用法和synchronized类似。比过它需要程序员手动添加加锁和解锁的代码。 比起synchronized的好处。它添加了两个方法： l  提供了tryLock()，该方法调用的时候。如果锁被另一个对象持有，它会返回false。 l  还一个就是公平锁。在构造ReentrantLock的时候。它拥有一个人boolean类型的参数。该参数就
Java并发之ReentrantLock类源码解析
08-27
Java并发之ReentrantLock类源码解析 ReentrantLock是Java并发包中的一种同步工具，它可以实现可重入锁的功能。ReentrantLock类的源码分析对理解Java并发机制非常重要。本文将对ReentrantLock类的源码进行详细分析，...
Java并发系列之ReentrantLock源码分析
08-27
Java并发系列之ReentrantLock源码分析 ReentrantLock是Java 5.0中引入的一种新的加锁机制，它实现了Lock接口，并提供了与synchronized相同的互斥性和内存可见性。ReentrantLock的底层实现是通过AQS来实现多线程同步...
java并发之ReetranLock
06-24
Java 并发之 ReentrantLock ReentrantLock 是 Java 并发包中的一个技术，在并发编程中非常常用。它是一个实现 Lock 接口的类，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞...
java并发之ArrayBlockingQueue详细介绍
08-30
Java并发之ArrayBlockingQueue详细介绍 ArrayBlockingQueue是Java并发编程中常用的线程安全队列，经常被用作任务队列在线程池中。它是基于数组实现的循环队列，具有线程安全的实现。 ArrayBlockingQueue的实现 ...
java并发编程2
02-15
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释： 1. **线程与并发** - **线程*...
Java锁ReentrantLock
CodingSoldier的博客
10-27 282
从Java 5之后，Java可使用Lock实现同步访问。首先说明，Lock并不是用来替代synchronized的。 synchronized有以下不足 效率低：锁的释放情况少、不能设置锁的超时时间、不能中断正在试图获得锁的线程。 不够灵活：加锁、释放锁的时机单一，进入同步同步代码块获取锁，离开释放锁。 与synchronized相比Lock可以提供更多高级功能。 ReentrantLock的基本使用 ...
java ReentrantLock应用
jie310600的博客
09-26 213
[b]java ReentrantLock应用[/b] ReentrantLock可重入锁 1.使用ReentrantLock接口要比使用synchronized关键字效率高一些 [b]不公平锁与公平锁的区别：[/b] [code="java"]private ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平...
java--ReentrantLock锁
qq_43539962的博客
12-22 175
ReentrantLock锁可重入可打断锁超时 ReentrantLock特点 可中断 可以设置超时时间 设置设置为公平锁（防止饥饿） 支持多个条件变量（类似synchronized的waitSet） 和synchronized一样都支持锁的重入 基本用法 ReentrantLock lock = new ReentrantLock(); lock.lock(); try { // 临界区代码 } finally {
java基础之ReentrantLock
nethackatschool的专栏
03-20 448
引言 之前我们说了java的synchronized同步关键字，解析了jdk1.6之后对其进行一系列优化原理分析，今天我们聊一聊java中另一个锁ReentrantLock。 synchronized同步关键字实现同步或者说独占是通过JVM底层进行系统调用操作Mutex Lock（互斥锁）实现的，而ReentrantLock则是通过上层代码实现，某种意义上可以说是锁的软实现（当然还是需要通过调用大...
java锁——ReentrantLock
此岸花开
03-27 323
java.util.concurrent.locks.Lock Lock接口与synchronized的区别： 1.Lock接口允许分离读和写操作，允许多个读线程和只有一个写线程 2.在高并发的环境下，Lock性能更好 3.支持更灵活的同步代码块结构，可以让锁的获取和释放不在同一个代码块 使用Lock接口的一般模式： private final Lock lock
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值