Java多线程编程-ReentrantLock(2)

最新推荐文章于 2023-04-09 18:27:16 发布
最新推荐文章于 2023-04-09 18:27:16 发布
阅读量238 收藏
点赞数
分类专栏： Java多线程 文章标签： Java多线程 Lock 锁 ReentrantLock API
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qian1314520hu/article/details/115481474
版权

Java多线程编程-ReentrantLock

公平锁和非公平锁

我们在使用java多线程编程的时候，经常会用到锁机制，锁分为公平锁和非公平锁。
公平锁：表示线程获取锁的顺序是按照线程加锁的顺序来进行分配的，先来先得先进先出的顺序进行的。
非公平锁：就是一种锁的抢占机制，是随机获取锁的，这样会有的线程一直获取不到锁，因此对于该线程来说是不公平的。

使用ReentrantLock实现公平锁

我们使用ReentrantLock时候，ReentrantLock的构造函数可以传入一个boolean类型的参数，根据不同的值返回不同的实现方式，源码如下：

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

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

由上面的代码可以看出，默认是进行不公平的锁机制，使用new NonfairSync()进行，公平锁为new FairSync()。因此创建ReentrantLock（true）使用公平锁策略，ReentrantLock（false）的时候使用非公平锁机制，因此 Java多线程编程-ReentrantLock(1)都是使用的默认的非公平锁策略。

公平锁

public class ReentrantLockObj {
    private ReentrantLock reentrantLock;
    public ReentrantLockObj(boolean isFair) {
        reentrantLock = new ReentrantLock(isFair);
    }
    public void fun() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name :" + Thread.currentThread().getName() + " get lock");
        } finally {
            reentrantLock.unlock();
        }
    }
}

运行：

public class ReentrantLockObjMain {

    public static void main(String[] args) {
        ReentrantLockObj reentrantLockObj = new ReentrantLockObj(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("current thread name:" + Thread.currentThread().getName() + " do running");
                reentrantLockObj.fun();
            }
        };
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(runnable, "thread" + i));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
    }
}

运行结果：
在这里插入图片描述
我们上面创建了10个线程，每个线程依次运行，说明我们使用ReentrantLock（true）创建的是公平锁。
我们可以将上面的true变为false，我们看看运行结果：

ReentrantLockObj reentrantLockObj = new ReentrantLockObj(false);

运行结果：
在这里插入图片描述
从上面的可以看出，线程的执行和获取锁的事混乱的。说明使用ReentrantLock（false）创建的非公平锁的使用。

ReentrantLock相关API

我们在使用ReentrantLock类进行锁操作的时候，只是用到了lock和unlock方法，我们看看源码：
lock():获取锁,如果没有其他线程持有该锁，则获取该锁并立即返回，将锁保持计数设置为1.如果当前线程已经持有该锁，则持有计数将增加一，并且该方法将立即返回。如果该锁由另一个线程持有，则出于线程调度目的，当前线程将被禁用，并且在获取该锁之前，该线程处于休眠状态，这时将锁持有计数设置为1。

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

sync对象是一个Sync接口，实现了Lock，根据是否为公平锁调用不同的实现，非公平锁如下：

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

公平锁如下：

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

ReentrantLock.getHoldCount()

getHoldCount():查询当前线程对该锁的保持次数（调用lock方法的次数）。对于每个未与解锁动作匹配的锁定动作，线程都会拥有一个锁。保留计数信息通常仅用于测试和调试目的.
源码：

public int getHoldCount() {
    return sync.getHoldCount();
}
//sync调用的方法
final int getHoldCount() {
    return isHeldExclusively() ? getState() : 0;
}

验证：

public class ReentrantLockAPIMain1 {
    private static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {
        testFun1();
    }
    public static void testFun1() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " call lock number:" + reentrantLock.getHoldCount());
            testFun2();
        } finally {
            reentrantLock.unlock();
        }
    }
    public static void testFun2() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " call lock number:" + reentrantLock.getHoldCount());
        } finally {
            reentrantLock.unlock();
        }
    }
}

运行结果：
在这里插入图片描述
上面是第一行是testFun1方法调用的，第二行是方法testFun2打印的，调用两次lock方法

ReentrantLock.getQueueLength()

getQueueLength():返回等待获取此锁的线程数的估计值。该值只是一个估计值，因为在此方法遍历内部数据结构时，线程数可能会动态变化。此方法设计用于监视系统状态，而不用于同步控制。
源码：

public final int getQueueLength() {
    return sync.getQueueLength();
}
//sync调用的方法 AbstractQueuedSynchronizer.Node
      /**
      * 要加入CLH锁，您可以自动将其作为新尾部进行拼接。要出队，您只需设置头字段。
      +------+  prev +-----+       +-----+
       head |      | <---- |     | <---- |     |  tail
            +------+       +-----+       +-----+ **/
public final int getQueueLength() {
    int n = 0;
    for (Node p = tail; p != null; p = p.prev) {
        if (p.thread != null)
            ++n;
    }
    return n;
}

验证：

public class ReentrantLockAPIMain2 {

    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                testFun1();
            }
        };
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(runnable, "thread" + i));
        }
        threadList.stream().forEach(thread -> {
            thread.start();
        });
        Thread.sleep(5000);
        System.out.println("wait lock number：" + reentrantLock.getQueueLength());
    }

    public static void testFun1() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " call lock number:" + reentrantLock.getHoldCount());
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

}

运行结果：
在这里插入图片描述
我们创建了10个线程，在一个线程中进行等待，剩余的9个线程正在等待获取锁，程序还没有结束。

ReentrantLock.getWaitQueueLength(Condition condition)

getWaitQueueLength(Condition condition):返回在与此锁关联的给定条件下等待的线程数的估计值。请注意，由于超时和中断可能随时发生，因此估算值仅用作实际侍者数的上限。此方法设计用于监视系统状态，而不用于同步控制。
源码：

public int getWaitQueueLength(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return 	sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
//sync调用的方法
public final int getWaitQueueLength(ConditionObject condition) {
        if (!owns(condition))
            throw new IllegalArgumentException("Not owner");
        return condition.getWaitQueueLength();
    }

验证：

public class ReentrantLockAPIMain3 {

    private static ReentrantLock reentrantLock = new ReentrantLock();
    private static Condition condition = reentrantLock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                testFun1();
            }
        };
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(runnable, "thread" + i));
        }
        threadList.stream().forEach(thread -> {
            thread.start();
        });
        Thread.sleep(5000);
        testFun2();
    }

    public static void testFun1() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " call lock number:" + reentrantLock.getHoldCount());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public static void testFun2() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " reentrantLock.getWaitQueueLength(condition) number:"
                    + reentrantLock.getWaitQueueLength(condition));
            condition.signal();
        } finally {
            reentrantLock.unlock();
        }
    }
}

运行结果：
在这里插入图片描述
这里使用同一个condition，所以获取的个数为10，如果创建多个condition的，和这个差不多，是针对不同condition进行统计。我们从上面的源码可以看出，如果不传condition的时候将抛出空指针异常。

ReentrantLock.isFair()

isFair():返回是否为公平锁
源码：

public final boolean isFair() {
    return sync instanceof FairSync;
}

有创建的源码可以看出，公平和非公平锁是根据sync 的不同实现来获得的。因此判断sync的实现是否为公平实现还是非公平实现即可。

ReentrantLock.hasQueuedThread(Thread thread)

hasQueuedThread(Thread thread):查询给定线程是否正在等待获取此锁。请注意，由于取消可能随时发生，因此返回{@code true}并不能保证该线程将获得此锁。此方法主要设计用于监视系统状态。
源码：

public final boolean hasQueuedThread(Thread thread) {
    return sync.isQueued(thread);
}
//调用sync方法 AbstractQueuedSynchronizer.hasQueuedThreads
public final boolean isQueued(Thread thread) {
    if (thread == null)
        throw new NullPointerException();
    for (Node p = tail; p != null; p = p.prev)
        if (p.thread == thread)
            return true;
    return false;
}

验证：

public class ReentrantLockAPIMain4 {

    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                testFun1();
            }
        };
        Thread thread = new Thread(runnable, "thread01");
        thread.start();
        Thread.sleep(5000);
        Thread thread1 = new Thread(runnable, "thread02");
        thread1.start();
        Thread.sleep(5000);
        System.out.println(reentrantLock.hasQueuedThread(thread));
        System.out.println(reentrantLock.hasQueuedThread(thread1));
    }

    public static void testFun1() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " call lock number:" + reentrantLock.getHoldCount());
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

}

运行结果：
在这里插入图片描述
从运行可以看出，线程1正在等待。

ReentrantLock.hasQueuedThreads()

hasQueuedThreads():查询是否有任何线程正在等待获取此锁。请注意，由于取消可能随时发生，因此返回true并不能保证任何其他线程都会获得此锁。此方法主要设计用于监视系统状态
这个方法和上面的方法功能基本上差不多，一个传入thread对象一个是针对所有的线程。

ReentrantLock.hasWaiters(Condition condition)

hasWaiters(Condition condition):查询是否有任何线程正在等待与此锁关联的给定条件。请注意，由于超时和中断随时可能发生，因此返回 true并不能保证将来的signal会唤醒任何线程。此方法主要设计用于监视系统状态。
源码：

public boolean hasWaiters(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
//sync调用的方法 AbstractQueuedSynchronizer.hasWaiters
public final boolean hasWaiters(ConditionObject condition) {
     if (!owns(condition))
         throw new IllegalArgumentException("Not owner");
     return condition.hasWaiters();
 }

验证：

public class ReentrantLockAPIMain5 {

    public static ReentrantLock reentrantLock = new ReentrantLock();

    public static Condition condition = reentrantLock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                testFun1();
            }
        };
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(runnable, "thread0" + i));
        }
        threadList.stream().forEach(thread -> thread.start());
        Thread.sleep(5000);
        testFun2();
    }

    public static void testFun1() {
        reentrantLock.lock();
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public static void testFun2() {
        reentrantLock.lock();
        try {
            System.out.println("has wait condition? " + reentrantLock.hasWaiters(condition) + " thread numbers is " + reentrantLock.getWaitQueueLength(condition));
            condition.signal();
        } finally {
            reentrantLock.unlock();
        }
    }
}

运行结果：
在这里插入图片描述
等待同一个condition条件的线程正在等待中的数为10，返回为true

ReentrantLock.isLocked()

isLocked():查询此锁定是否由任意线程保持
源码：

final boolean isLocked() {
    return getState() != 0;
}

ReentrantLock.isHeldByCurrentThread()

isHeldByCurrentThread():查询此锁是否由当前线程持有。类似于内置监视器锁的ThreadholdsLock(Object)方法，该方法通常用于调试和测试。
源码：

public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
}
//sync调用方法
protected final boolean isHeldExclusively() {
    // While we must in general read state before owner,
    // we don't need to do so to check if current thread is owner
    return getExclusiveOwnerThread() == Thread.currentThread();
}

ReentrantLock.lockInterruptibly()

lockInterruptibly()：除非当前线程为Threadinterrupt interrupted，否则获取锁。如果没有其他线程持有该锁，则获取该锁并立即返回，将锁保持计数设置为1.如果当前线程已经持有此锁，则持有计数将增加一，并且该方法将立即返回。如果该锁由另一个线程持有，则出于线程调度的目的，当前线程将被禁用，并处于休眠状态，直到发生以下两种情况之一：
1.该锁由当前线程获取
2.当前线程还有其他一些线程Threadinterrupt interrupts
源码：

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}
//sync调用的方法 AbstractQueuedSynchronizer.acquireInterruptibly
public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

验证：

public class ReentrantLockAPIMain6 {
    public static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                testFun1();
            }
        };
        Thread thread = new Thread(runnable, "thread01");
        thread.start();
        Thread.sleep(1000);
        Thread thread1 = new Thread(runnable, "thread02");
        thread1.start();
        thread1.interrupt();
    }

    public static void testFun1() {
        reentrantLock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " get lock");
            for (int i = 0; i < 6000; i++) {
                Math.random();
            }
            System.out.println("get lock end " + Thread.currentThread().getName());
        } finally {
            if (reentrantLock.isHeldByCurrentThread()) {
                reentrantLock.unlock();
            }
        }
    }
}

运行结果：
在这里插入图片描述
可以运行成功，我们使用lockInterruptibly方法试试：我们将lock方法变为lockInterruptibly方法

 reentrantLock.lockInterruptibly();

运行会出现报错信息：
在这里插入图片描述

ReentrantLock.tryLock()和ReentrantLock.tryLock(long time,TimeUnit unit)

tryLock():仅在调用时另一个线程未持有该锁时才获取该锁。如果没有其他线程持有该锁，则获取该锁，并立即返回值true，并将锁保持计数设置为1。即使已将此锁设置为使用公平的排序策略，如果可用，则对tryLock()的调用将立即获取该锁，无论当前是否有其他线程在等待该锁。锁。即使破坏公平性，这种“讨价还价”的行为在某些情况下还是有用的。如果要遵守此锁的公平性设置，请使用几乎等效的tryLock(long,TimeUnit)方法,tryLock(0,TimeUnit.SECONDS)（它还会检测到中断）。如果当前线程已经持有此锁，则持有计数将增加1，并且该方法返回true.如果锁由另一个线程持有，则此方法将立即返回值false

Tony-devj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
Java多线程学习笔记：ReentrantLock，Condition，ReentrantReadWriteLock
CrankZ的博客
11-07 357
ReentrantLock ReentrantLock和synchronized关键字一样可以用来实现线程之间的同步互斥，但是在功能是比synchronized关键字更强大而且更灵活。 ReentrantLock 整体结构如下图： 常用接口分析 构造器 ReentrantLock()创建一个 ReentrantLock的实例。 ReentrantLock(boolean fai...
Java多线程：ReentrantLock中的方法
qq_38470315的博客
04-09 439
ReentrantLock有一个很大的特点，就是可以指定锁是公平锁还是非公平锁，公平锁表示线程获取锁的顺序是按照线程排队的顺序来分配的，而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，先来的未必就一定能先得到锁，从这个角度讲，synchronized其实就是一种非公平锁。由于t0先启动获得了锁，因此不等待，返回false，另外两个线程则要等待获取t0的锁，因此返回的是true，而此ReentrantLock中有线程在等待，所以hasQueuedThreads()返回的是true。
ReentrantLock
berber78的专栏
03-13 371
ReentrantLock是可重入锁，或者说其持有一个锁计数器，当已持有所的线程再次获得该锁时计数器值加1，每调用一次lock.unlock()时所计数器值减一，直到所计数器值为0，此时线程释放锁； 一般try前执行lock()，try中为受保护代码段； finally中执行unlock()可以保证发生异常 锁可以得到释放 避免死锁的发生； ReentrantLock的主要缺点是方法需要置于...
【java学习积累】ReentrantLock Condition的使用
xiangzaixiansheng的博客
06-23 2014
一、ReentrantLock 的方法介绍 下面列举一些常见的ReentrantLock的方法。 int getHoldCount()：查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。 int getQueueLength()：返回正等待获取此锁定的线程估计数。比如有5个线程，1个线程首先执行await()方法，那么在调用getQueueLength方法后返回值是4，说明有4...
Java并发知识之ReentrantLock
拥抱大数据的专栏
01-22 404
深入理解ReentrantLock设计思想和原理
Java多线程并发编程(互斥锁Reentrant Lock)
08-30
主要介绍了ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃,需要的朋友可以参考下
Java并发编程相关技术使用案例
最新发布
08-09
1、本资源包含并发编程基础知识的使用案例，包括：线程创建、Synchronized和Reentrantlock锁的使用、线程安全问题演示、Condition的应用、CountDownLatch的应用、Cyclicbarrier的应用、Semaphore的应用、线程池的...
【2018最新最详细】并发多线程教程
11-15
【2018最新最详细】并发多线程教程，课程结构如下 1.并发编程的优缺点 2.线程的状态转换以及基本操作 3.java内存模型以及happens-before规则 4.彻底理解synchronized 5.彻底理解volatile 6.你以为你真的了解final吗...
JDK自带多线程工具包详解
06-30
由浅入深，通过图解和手写代码，讲解Java版的多线程，主要讲解如下内容： CPU运转机制 线程运行原理及线程状态 AQS原理&源码解读 线程同步+各种锁的原理&手写实现 JDK多线程工具包中，若干种工具的原理和手写实现： ...
ReentrantLock详解(可重入、可中断、锁超时、公平锁、条件变量)、同步模式之顺序控制
热门推荐
张大安的博客
03-12 1万+
文章目录1.ReentrantLock详解1.1 可重入1.2 可中断 lockInterruptibly()1.3 设置超时时间 tryLock()1.4 通过lock.tryLock()来解决, 哲学家就餐问题1.5 公平锁 new ReentrantLock(true)1.6 条件变量 Condition 1.ReentrantLock详解 相对于synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样,都支持可重入
ReentrantLock锁
weixin_46121031的博客
05-14 6438
1. 简介 ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于 synchronized 的使用，但是 ReentrantLock 提供了比 synchronized 更强大、灵活的锁机制，可以减少死锁发生的概率
ReentrantLock详解
weixin_56738054的博客
01-09 5346
ReentrantLock使用，
ReentrantLock介绍及使用(超详细)
Mr.绵羊的知识星球
02-17 9463
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
Lock的lockInterruptibly()方法
az44yao的专栏
03-27 1万+
lockInterruptibly()方法能够中断等待获取锁的线程。当两个线程同时通过lock.lockInterruptibly()获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。 示例： 要执行doBussiness()中的代码首先需要得到锁lock，线程使用lockInterruptibly()...
ReentrantLock 锁详解
m0_37235955的博客
04-27 3053
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
ReentrantLock并发锁使用详解
Huangjiazhen711的博客
10-13 1352
进入源码可以看到，其实现了公平锁和非公平锁内部实现了加锁的操作，并且支持重入锁。不用我们再重写解锁操作。
ReentrantLock api 详解
小白爱学习的专栏
06-22 593
今天学习ReentrantLock工具类，该类是JUC原子包中的类，通过单元测试代码把所有public api方法跑了一遍，大致了解了底层实现，初学乍练，有很多一知半解的地方，待后续有了深入理解再来补充 package test.java.util.concurrent.locks; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurren
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 2869
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
jmu-java-07多线程-同步访问
06-28
多线程编程在提高程序性能、增强程序交互性等方面有很大的优势，但也会引入一些问题，比如线程安全问题。 当多个线程同时访问共享资源时，可能会出现线程不安全的问题，比如数据竞争、死锁等。为了避免这些问题，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值