精华内容
下载资源
问答
  • 锁的重入是指同一个线程可以多次获取同一个锁,synchronize是隐式的可重入锁,ReentrantLock通过代码实现了锁的重入:final boolean nofairTryAcquire(int acquires){final Thread current=Thread.currentThread();...

    锁的重入是指同一个线程可以多次获取同一个锁,synchronize是隐式的可重入锁,ReentrantLock通过代码实现了锁的重入:

    final boolean nofairTryAcquire(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) throw new Error("Maximum lock count exceeded");

    setState(nextc);

    return true;

    }

    return false;

    }

    从上面的代码中,可以一目了然的发现,当获取锁的线程与拥有锁的线程是同一个线程时,仅会对状态进行累加。so easy ,并没有什么难度。那接下来我们想一下,如何实现公平所和非公平锁,上面的代码是非公平锁的实现方式。那如何实现公平锁那?所谓的公平锁就是所有获取锁的线程都要按照“先来后到”的顺序获取锁。假设线程B在阻塞队列中,等待获取锁,如果还有一个线程A在B的前面,那么B就要让A先获取锁。因此在B尝试获取锁之前,只要判断一下它是否还有前驱的队列即可。很easy吧:

    final boolean fairTryAcquire(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;

    }

    公平所和非公平锁的各自优势是什么那?公平锁很好理解,可以防止出现线程饥饿现象,每一个线程都有机会获取到锁。非公平锁可能会导致线程饥饿,但是我们一般使用非公平锁,因为非公平锁可以减少上下文的切换,提高效率。

    展开全文
  • ReentrantLocksynchronized都是可重入锁,下面是一个用synchronized实现的例子: public class ReentrantTest implements Runnable { public synchronized void get() { System.out.println(Th

    释义

    广义上的可重入锁指的是可重复可递归调用的锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁(前提得是同一个对象或者class),这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁,下面是一个用synchronized实现的例子:

    public class ReentrantTest implements Runnable {
    
        public synchronized void get() {
            System.out.println(Thread.currentThread().getName());
            set();
        }
    
        public synchronized void set() {
            System.out.println(Thread.currentThread().getName());
        }
    
        public void run() {
            get();
        }
    
        public static void main(String[] args) {
            ReentrantTest rt = new ReentrantTest();
            for(;;){
                new Thread(rt).start();
            }
        }
    }
    
    

    set()和get()同时输出了线程名称,表明即使递归使用synchronized也没有发生死锁,证明其是可重入的.

    不可重入锁

    不可重入锁,与可重入锁相反,不可递归调用,递归调用就发生死锁。看到一个经典的讲解,使用自旋锁来模拟一个不可重入锁,代码如下:

    import java.util.concurrent.atomic.AtomicReference;
    
    public class UnreentrantLock {
    
        private AtomicReference<Thread> owner = new AtomicReference<Thread>();
    
        public void lock() {
            Thread current = Thread.currentThread();
            //这句是很经典的“自旋”语法,AtomicInteger中也有
            for (;;) {
                if (!owner.compareAndSet(null, current)) {
                    return;
                }
            }
        }
    
        public void unlock() {
            Thread current = Thread.currentThread();
            owner.compareAndSet(current, null);
        }
    }
    

    代码也比较简单,使用原子引用来存放线程,同一线程两次调用lock()方法,如果不执行unlock()释放锁的话,第二次调用自旋的时候就会产生死锁,这个锁就不是可重入的,而实际上同一个线程不必每次都去释放锁再来获取锁,这样的调度切换是很耗资源的。稍微改一下,把它变成一个可重入锁:

    import java.util.concurrent.atomic.AtomicReference;
    
    public class UnreentrantLock {
    
        private AtomicReference<Thread> owner = new AtomicReference<Thread>();
        private int state = 0;
    
        public void lock() {
            Thread current = Thread.currentThread();
            if (current == owner.get()) {
                state++;
                return;
            }
            //这句是很经典的“自旋”式语法,AtomicInteger中也有
            for (;;) {
                if (!owner.compareAndSet(null, current)) {
                    return;
                }
            }
        }
    
        public void unlock() {
            Thread current = Thread.currentThread();
            if (current == owner.get()) {
                if (state != 0) {
                    state--;
                } else {
                    owner.compareAndSet(current, null);
                }
            }
        }
    }
    

    在执行每次操作之前,判断当前锁持有者是否是当前对象,采用state计数,不用每次去释放锁。

    ReentrantLock中可重入锁实现

    这里看非公平锁的锁获取方法:

            final boolean nonfairTryAcquire(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;
            }
    

    在AQS中维护了一个private volatile int state来计数重入次数,避免了频繁的持有释放操作,这样既提升了效率,又避免了死锁。

    展开全文
  • 锁的重入是指同一个线程可以多次获取同一个锁,synchronize是隐式的可重入锁,ReentrantLock通过代码实现了锁的重入: final boolean nofairTryAcquire(int acquires){ final Thread current=Thread.currentThread...
        
    锁的重入是指同一个线程可以多次获取同一个锁,synchronize是隐式的可重入锁,ReentrantLock通过代码实现了锁的重入:
        final boolean nofairTryAcquire(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) throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

    从上面的代码中,可以一目了然的发现,当获取锁的线程与拥有锁的线程是同一个线程时,仅会对状态进行累加。so easy ,并没有什么难度。那接下来我们想一下,如何实现公平所和非公平锁,上面的代码是非公平锁的实现方式。那如何实现公平锁那?所谓的公平锁就是所有获取锁的线程都要按照“先来后到”的顺序获取锁。假设线程B在阻塞队列中,等待获取锁,如果还有一个线程A在B的前面,那么B就要让A先获取锁。因此在B尝试获取锁之前,只要判断一下它是否还有前驱的队列即可。很easy吧:

    final boolean fairTryAcquire(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;
        }

    公平所和非公平锁的各自优势是什么那?公平锁很好理解,可以防止出现线程饥饿现象,每一个线程都有机会获取到锁。非公平锁可能会导致线程饥饿,但是我们一般使用非公平锁,因为非公平锁可以减少上下文的切换,提高效率。

    展开全文
  • Java 重入锁和读写锁

    2021-03-10 22:43:30
    重入锁 ReentrantLock,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁。除此之外,该锁还支持获取锁时的公平和非公平性选择 所谓不支持重进入,可以考虑如下场景:当一个线程调用 lock...

    本文部分摘自《Java 并发编程的艺术》


    重入锁

    重入锁 ReentrantLock,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁。除此之外,该锁还支持获取锁时的公平和非公平性选择

    所谓不支持重进入,可以考虑如下场景:当一个线程调用 lock() 方法获取锁之后,如果再次调用 lock() 方法,则该线程将会被自己阻塞,原因是在调用 tryAcquire(int acquires) 方法时会返回 false,从而导致线程阻塞

    synchronize 关键字隐式的支持重进入,比如一个 synchronize 修饰的递归方法,在方法执行时,执行线程在获取锁之后仍能连续多次地获得该锁。ReentrantLock 虽然不能像 synchronize 关键字一样支持隐式的重进入,但在调用 lock() 方法时,已经获得锁的线程,能够再次调用 lock() 方法获取锁而不被阻塞

    1. 实现重进入

    重进入特性的实现需要解决以下两个问题:

    • 线程再次获取锁

      锁需要去识别获取锁的线程是否为当前占据锁的线程,如果是,则再次成功获取

    • 锁的最终释放

      线程重复 n 次获取锁,随后在第 n 次释放该锁后,其他线程能获取到锁。实现此功能,理应考虑使用计数

    ReentrantLock 通过组合自定义同步器来实现锁的获取与释放,以非公平锁实现为例,获取同步状态的代码如下所示,主要是增加了再次获取同步状态的处理逻辑

    final boolean nonfairTryAcquire(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()) {
            // 将同步值进行增加,并返回 true
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
    

    考虑到成功获取锁的线程再次获取锁,只是增加同步状态值,这也就要求 ReentrantLock 在释放同步状态时减少同步状态值,该方法代码如下:

    protected final boolean tryRelease(int releases) {
        // 减少状态值
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 当同步状态为0,将占有线程设为null,并返回true,表示释放成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
    

    2. 公平与非公平获取锁的区别

    如果一个锁是公平的,那么锁的获取顺序就应该符合请求的绝对时间顺序,也即 FIFO。回顾上一节,非公平锁只要 CAS 设置同步状态成功,即表示当前线程获取了锁,而公平锁则不同,代码如下:

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            /* 
             * 唯一不同的就是判断条件多了 hasQueuedPredecessors()
             * 该方法用来判断当前节点是否有前驱节点
             * 如果该方法返回 true,表示有线程比当前线程更早请求获取锁
             * 因此需要等待前驱线程释放锁之后才能继续获取锁
             */
            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;
    }
    

    读写锁

    之前提到的锁基本都是排它锁,同一时刻只允许一个线程访问,而读写锁在同一时刻可以允许多个线程访问,但在写线程访问时,所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁,一个读锁和一个写锁,通过分离读锁和写锁,使得并发性相比一般的排它锁有了很大提升

    1. 接口示例

    下面通过缓存示例说明读写锁的使用方式

    public class Cache {
    
        static Map<String, Object> map = new HashMap<>();
        static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
        static Lock r = rwl.readLock();
        static Lock w = rwl.writeLock();
    
        /**
         * 获取一个 key 对应的 value
         */
        public static Object get(String key) {
            r.lock();
            try {
                return map.get(key);
            } finally {
                r.unlock();
            }
        }
    
        /**
         * 设置 key 对应的 value,并返回旧的 value
         */
        public static Object put(String key, Object value) {
            w.lock();
            try {
                return map.put(key, value);
            } finally {
                w.unlock();
            }
        }
    
        /**
         * 清空所有的内容
         */
        public static void clear() {
            w.lock();
            try {
                map.clear();
            } finally {
                w.unlock();
            }
        }
    }
    

    2. 读写状态的设计

    读写锁同样依赖自定义同步器来实现功能,而读写状态就是其同步器状态。读写锁的自定义同步器需要在同步状态(一个整型变量)上维护多个读线程和一个写线程的状态,为此需要读写锁将变量切分成两部分,高 16 位表示读,低 16 位表示写

    在这里插入图片描述

    上图表示一个线程已经获取了写锁,且重进入了两次,同时也连续两次获取了读锁。通过位运算可以迅速确定读和写各自的状态,假设当前同步状态值为 S,则:

    • 写状态等于 S & 0x0000FFFF(将高 16 位全部抹去)
    • 读状态等于 S >>> 16(无符号右移 16 位)
    • 当写状态增加 1 时,等于 S + 1
    • 当读状态增加 1 时,等于 S + (1<<6),也就是 S + 0x00010000

    根据状态的划分能得出一个结论:S 不等于 0 时,当写状态(S & 0x0000FFFF)等于 0 时,则读状态(S >>> 16)大于 0,即读锁已被获取

    3. 写锁的获取与释放

    写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁,则增加写状态。如果当前线程在获取写锁时,读锁已被获取,或者该线程不是获取写锁的线程,则当前线程进入等待状态,获取写锁的代码如下:

    protected final boolean tryAcquire(int acquires) {
        Thread current = Thread.currentThread();
        int c = getState();
        // exclusiveCount 方法会用 c & 0x0000FFFF,即得出写状态个数
        int w = exclusiveCount(c);
        if (c != 0) {
            // 根据上面提到的推论,c 不等于 0,而 w 等于 0,证明存在读锁
            // 当前线程也不是获取了写锁的线程
            if (w == 0 || current != getExclusiveOwnerThread())
                return false;
            if (w + exclusiveCount(acquires) > MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            setState(c + acquires);
            return true;
        }
        if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
            return false;
        setExclusiveOwnerThread(current);
        return true;
    }
    

    写锁的每次释放均会减少写状态,当写状态为 0 时表示写锁已被释放,从而等待的读写线程能够继续访问读写锁,同时前次写线程的修改对后续读写线程可见

    4. 读锁的获取与释放

    读锁是一个支持重进入的共享锁,它能被多个线程同时获取,在没有其他写线程访问时,读锁总能被成功获取,这里对获取读锁的代码做了简化:

    protected final int tryAcquireShared(int unused) {
    
        for(;;) {
            int c = getState();
            int nextc = c + (1<<16);
            if(nextc < c) {
                throw new Error("Maximum lock count exceeded");
            }
            // 如果其他线程已经获取写锁,则读取获取失败
            if(exclusiveCount(c) != 0 && owner != Thread.currentThread()) {
                return -1;
            }
            if(compareAndSetState(c, nextc)) {
                return 1;
            }
        }
    }
    

    读锁的每次释放均减少读状态,减少的值是 1<<16

    5. 锁降级

    锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁,然后将其释放,最后再获取读锁,这种分段完成的过程不能称之为锁降级。锁降级是指把持住写锁,再获取读锁,随后释放写锁的过程

    public void processData() {
        readLock.lock();
        if(!update) {
            // 必须先释放读锁
            readLock.unlock();
            // 锁降级从写锁获取到开始
            writeLock.lock();
            try {
    			if(!update) {
                    // 准备数据的流程(略)
                    update = true;
                }
                readLock.lock();
            } finally {
                writeLock.unlock();
            }
        }
        try {
            // 使用数据的流程(略)
        } finally {
            readLock.unlock();
        }
    }
    

    上例中,当数据发生变更,则 update(使用 volatile 修饰)被设置为 false,此时所有访问 processData 方法的线程都能感知到变化,但只有一个线程能获取到写锁,其余线程会被阻塞在写锁的 lock 方法上。当前线程获取写锁完成数据准备之后,再次获取读锁,随后释放写锁,完成锁降级


    相关示例代码请查阅 https://github.com/Yee-Q/Thread-Art-Demo


    展开全文
  • 锁的种类:读写锁 悲观锁乐观锁 CSA无锁自旋锁AQS 公平锁 公平锁 互斥锁 排它锁 分布式锁(redis实现 zk实现)轻量级锁(lock),重量级锁(synchronize)重入锁锁作为并发共享数据,保证一致性的工具,在JAVA平台有...
  • 重入锁和不可重入锁的概念: 1.可重入锁: 所谓可重入锁,意味着线程可以进入它已经拥有的锁的同步代码块儿. 2.可重入锁 所谓不可重入锁,即若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取...
  • java 重入锁和读写锁

    2018-03-30 10:57:07
    重入锁 顾名思义,就是支持重进入的锁,他表示该锁能够支持一个线程对资源的重复加锁,并且支持获取锁的公平和非公平性选择。synchronized 关键字隐私支持重进入,ReentrantLock在调用lock 方法时候,已经获取到...
  • 1 . 什么是可重入锁锁的概念就不用多解释了,当某个线程A已经持有了一个锁,当...可以使用自己已经获取到的锁,这就是可重入锁java里面内置锁(synchronize)Lock(ReentrantLock)都是可重入的2 . 为什么要可重入如果线...
  • java里面最常见的锁,ReentrantLocksynchronized都是可重入锁 不可重入锁:不可重入锁,与可重入锁相反,不可递归调用,递归调用就发生死锁。即若当前线程执行某个方法已经获取了该锁,那么在方法...
  • 重入锁重入锁

    千次阅读 多人点赞 2019-08-09 19:06:09
    重入锁重入锁重入锁又称递归锁,是指同一个线程...Java中的ReentrantLocksynchronized都是可重入锁,可重入锁的一个优点就是可以避免死锁,下面结合源码分析 public class Wedget{ public synchroniz...
  • 乐观与悲观是一种广义的概念, 体现了看待多线程同步的不同角度, 在Java和数据库都有此概念对应的实际应用. 悲观: 悲观认为自己在使用数据的时候一定有别的线程来修改数据, 因此在获取数据的时候会先加锁, ...
  • 公平和非公平公平:是指多个线程按照申请的顺序来获取值。在并发环境中,每一个线程在获取时会先查看此维护的等待队列,如果为空,或者当前线程是等待队列的第一个就占有,否者就会加入到等待队列中,以后...
  • java中有公平锁、公平锁、可重入锁(递归锁)、自旋锁、独占锁(写锁)、共享锁(读锁)……编程公平锁 公平锁并发是什么:公平锁:是指多个线程按照申请的顺序来获取值函数公平锁:是值多个线程获取值的顺序并非...
  • 重入锁又名递归锁,是指在同一个...Java中ReentrantLocksynchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。 之前我们说过ReentrantLocksynchronized都是重入锁,那么我们通过重入锁Reent...
  • Java常见锁(公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁)一、公平锁和非公平锁二、java锁之可重入锁(递归锁)三、自旋锁四、独占锁(写锁)/ 共享锁(读锁)/ 互斥锁五、八锁问题 一、公平锁和非公平锁 ...
  • 锁—可重入锁 VS 重入锁 ...Java中ReentrantLocksynchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。下面用示例代码来进行分析: 在上面的代码中,类中的两个方法都是被内
  • 锁—可重入锁 VS 重入锁 ...Java中ReentrantLocksynchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。下面用示例代码来进行分析: 在上面的代码中,类中的两个方法都是被内置锁synchronized
  • //公平入锁 java.util.concurrent.locks.ReentrantLock$FairSync.java protected final boolean tryAcquire( int acquires) { final Thread current = Thread.currentThread(); int c = getState(...
  • ReentranLook分为公平锁和非公平锁,它们的区别是获取锁的机制上是否公平。ReentrantLook通过一个队列来维护获取该锁的线程,如果是公平锁,则线程会依次获取锁;非公平锁,只要锁是空闲的,不管是不是位于队列的一...
  • 重入锁又名递归锁,是指在同一个...Java中ReentrantLocksynchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。 之前我们说过ReentrantLocksynchronized都是重入锁,那么我们通过重入锁Reent...
  • 重入锁 ...java 1.5以后提供了ReentrantLock 实现重入锁功能。ReentrantLock 支持公平锁和非公平锁。 重进入的实现-非公平锁 前边两篇中我们提到过锁的底层实现就是 实现AQS的 tryAcquires 等方法。重...
  • 一、公平公平1.1 概述公平:是指多个线程按照申请的顺序来获取公平:是指在多线程获取的顺序并不是按照申请的顺序,有可能后申请的线程比先申请的线程优先获取到,在高并发的情况下,有...
  • 大厂面试题:公平锁/公平锁/重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁。大厂面试题:公平锁/公平锁/重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁。 1、什么是可重入锁(递归锁) 可重入锁...
  • 我们常听到的关于锁的词有:排它锁、共享锁、乐观锁、悲观锁、分段锁、自旋锁、公平锁、公平锁、可重入锁等。这些大多是对锁进行类型划分,彼此之间很多是兼容的,有的是对立的。 我们常用的Java中的锁有:CAS机制...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 785
精华内容 314
关键字:

java重入锁和非重入锁

java 订阅