Java多线程-09 （Lock锁之ReentrantLock可重入锁）

最新推荐文章于 2024-04-22 08:10:15 发布
最新推荐文章于 2024-04-22 08:10:15 发布
阅读量455 收藏 1
点赞数 1
分类专栏： 多线程 文章标签： 多线程 lock ReentrantLock 锁 可重入锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43260996/article/details/119522147
版权

                                                        ReentrantLock 

                                                                                             个人博客：www.xiaobeigua.icu 

        synchronized被称为内部锁，在 JDK5 中增加了Lock 锁接口,lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。这也是多线程编程中一种保护线程安全的重要机制， 它也被称为外部所，此接口有多个实现类,下面我们就来学习下Lock接口的一些实现类

                                                                               

1.1 锁的可重入性

        锁的可重入是指,当一个线程获得一个对象锁后,再次请求该对象 锁时是可以获得该对象的锁的.

/**
 * 作者：小北呱
 */
public class text6 {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                m1();
            }
        }).start();
    }

    //创建m1调用m2
    static synchronized void m1(){
        System.out.println(Thread.currentThread().getName()+"获得锁1");
        //调用m2
        m2();
    }

    static  synchronized void m2(){
        System.out.println(Thread.currentThread().getName()+"获得锁2");
    }
}

结果：

1.2 ReentrantLock

ReentrantLock 锁是Lock接口实现类之一，称为可重入锁, 它功能比 synchronized多

 1.2.1ReentranLock中实现Lock接口的方法

lock​()

获得锁。

unlock​()

释放锁。

tryLock​()

只有在调用时才可以获得锁。

tryLock​(long time, TimeUnit unit)

如果在给定的等待时间内没有锁定，并且当前线程尚未被 interrupted获取锁定。

lockInterruptibly​()

获取锁定，除非当前线程是 interrupted 。

newCondition​()

返回一个新Condition绑定到该实例Lock实例。

1.2.2 ReentrantLock 的基本使用

        调用 lock()方法获得锁, 调用 unlock()释放锁

代码：

public class text4 {
    //创建可重入锁
    Lock lock=new ReentrantLock();

    public static void main(String[] args) {
        text4 t4=new text4();
        //创建线程执行t4.toLock()方法
        Runnable runnable =new Runnable() {
            @Override
            public void run() {
                t4.toLock();
            }
        };
        //开启3个线程打印0-2
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();

    }

    //创建方法打印 0到2
    public void  toLock(){
        try {
            lock.lock();
            for(int i=0;i<3;i++){
                System.out.println(Thread.currentThread().getName()+"---"+i);
            }
        } finally {
            lock.unlock();
        }

    }
}

结果：

 1.2.3 ReentrantLock 锁的可重入性

public class text4 {
    //创建可重入锁
    Lock lock=new ReentrantLock();

    public static void main(String[] args) {
        text4 t4=new text4();
        //创建线程执行1内部类方法
        Runnable runnable =new Runnable() {
            @Override
            public void run() {
                t4.toLock();
            }
        };

        new Thread(runnable).start();
        new Thread(runnable).start();



    }

    //创建方法获得两个锁
    public void  toLock(){
        System.out.println(Thread.currentThread().getName()+"进入toLock方法");
        try {
            //测试重入性 获得两次锁
            lock.lock();
            lock.lock();
            for(int i=0;i<3;i++){
                System.out.println(Thread.currentThread().getName()+"获得2个锁");
            }
        } finally {
            System.out.println(Thread.currentThread().getName()+"退出2个锁");
            lock.unlock();
            lock.unlock();
        }

    }
}

结果：

 注意 进入多少个锁就要释放多少个锁，不然就会阻塞别的线程引起死锁

 比如：将上述代码中的两个 lock.unlock()改为一个

                 

则：线程 Thread--1无法获得两个锁，就会导致它一直处于等待状态

                

 1.2.4 lockInterruptibly()方法

        lockInterruptibly() 方法的作用:如果当前线程未被中断则获得锁, 如果当前线程被中断则出现异常。

        对于内部锁 synchronized 来说,如果一个线程在等待锁,只有两个结果:要么该线程获得锁继续执行;要么就保持等待. 对于 ReentrantLock 可重入锁来说,提供另外一种可能,在等待锁的过程中,程序可以根据需要取消对锁的请求，这点就比 synchronized要舒服的多。

例子 ：创建2个线程来使用 用lockInterruptibly()锁主的方法

public class test5 {
    public static Lock lock=new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        test5 t5=new test5();
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                try {
                    t5.toLock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread t1=new Thread(runnable);
        Thread t2=new Thread(runnable);
        t1.start();
        Thread.sleep(1000);
        t2.start();
        t2.interrupt();

    }

    public void toLock() throws InterruptedException {
        //创建一个循环模拟耗时操作 例：创建int 类型的最大数次的String 对象
        lock.lockInterruptibly();
        System.out.println(Thread.currentThread().getName()+"开始创建String对象");
        for (int i=0;i<Integer.MAX_VALUE;i++){
            new String();
        }
        lock.unlock();
        System.out.println(Thread.currentThread().getName()+"创建对象结束");
    }
}

结果：

        可以发现代码中，我们不干预线程0执行，所以它正常执行完毕输出

        我们再main方法中调用了  t2.interrupt().把干开始执行的线程1给中断了，因为我们用的是 lock.lockInterruptibly()方法，所以抛出了异常。

注意：我们如果把lock.lockInterruptibly()改为 lock.lock()

结果：

         发现线程1调用了  t2.interrupt()，它还是完美执行，这是因为 使用 lock()方法锁就和使用synchronized内部锁是类似的，线程只有两种结果 要么获得锁执行， 要么等待，在等待中，是无法用interrupt()进行中断的。

 1.2.5 tryLock()方法

         tryLock(long time, TimeUnit unit) 的作用在给定等待时长内锁没有被另外的线程持有,并且当前线程也没有被中断,则获得该锁.通过该方法可以实现锁对象的限时等待。

         tryLock()和tryLock(long time, TimeUnit unit) 都表示的是用来尝试获取锁：成功获取则返回true；获取失败则返回false。

        使用tryLock()和tryLock(long time, TimeUnit unit)可以解决死锁问题，这是synchronized内部锁不具备的，也是Lock()的强大之处

        就是你去上厕所，里面有人，你尝试等几分钟，时间到了，如果人出来了，你也没有因为别的事离开，那就到你上厕所了，如果时间过了，人还没出来，那你就放弃等待。

                                           

例子：用tryLock(long time, TimeUnit unit)设置两个线程去争夺一个锁：

public class Test8 {
    //定义可重入锁
    private Lock lock=new ReentrantLock();

    public static void main(String[] args) {

        Test8 t8=new Test8();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t8.doThing();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8.doThing();
            }
        }).start();

    }

    //定义线程要做的任务
    public void doThing() {
        try {
            System.out.println(Thread.currentThread().getName()+"尝试获得锁....");
            //如果锁被别的线程占用，尝试等待3秒 ，这段时间内获得锁，就继续执行，没有就放弃
            if (lock.tryLock(3, TimeUnit.SECONDS)){//返回值为布尔值 true 或 false
                System.out.println("成功");
                System.out.println(Thread.currentThread().getName()+"获得锁，正在执行任务...");
                Thread.sleep(4000);//模拟执行任务花了4秒
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

结果： 

   结论：

         线程0和线程1都在尝试获得锁，线程1先获得锁，进入执行任务需要4秒，而线程0使用tryLock()，方法只尝试等待3秒 ，所以时间到了，线程1未执行完任务，线程0未获得锁，所以，线程0退出等待，抛出异常。 

 如果我们把执行任务的时间改成小于线程等待锁的时间 那两个线程就可以正常获得锁了

 结果：

                

   结论：现在2线程个线程都获得了锁，执行了任务，因为在等待时间3s内 别的线程已经释放了锁

         tryLock()不设置等待时间，仅在调用时锁定未被其他线程持有的锁,如果调用方法时, 锁对象对其他线程持有,则放弃. 调用方法尝试获得没,如果该锁没有 被其他线程占用则返回 true 表示锁定成功; 如果锁被其他线程占用 则返回 false,不等待。

        相当于我去上厕所，看到里面有人，我直接扭头就走，不等待，没人我就进去！

例子： 把tryLock(long time, TimeUnit unit)改成 tryLock(）其余和上面一样

public class Test8 {
    //定义可重入锁
    private Lock lock=new ReentrantLock();

    public static void main(String[] args) {

        Test8 t8=new Test8();
        //线程0
        new Thread(new Runnable() {
            @Override
            public void run() {
                t8.doThing();
            }
        }).start();
        
        //线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                t8.doThing();
            }
        }).start();

    }

    //定义线程要做的任务
    public void doThing() {
        try {
            System.out.println(Thread.currentThread().getName()+"尝试获得锁....");
            //如果锁被别的线程占用，不等待
            if (lock.tryLock()){//返回值为布尔值 true 或 false
                System.out.println("成功");
                System.out.println(Thread.currentThread().getName()+"获得锁，正在执行任务...");
                Thread.sleep(2000);//模拟执行任务花了4秒
            }else {
                System.out.println(Thread.currentThread().getName()+"获取锁失败！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 结果：

 结论：发现使用tryLock()线程未获得锁不会等待，就直接退出了，符合我们的理解

1.2.6 newCondition()方法

        关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实 现等待/通知模式。

         Lock 锁的 newContition()方法返回 Condition 对 象，Condition 类也可以实现等待/通知模式. 使用 notify()通知时, JVM 会随机唤醒某个等待的线程，使用 Condition 类可以进行选择性通知。Condition 比较常用的两个方法:

        await()会使当前线程等待,同时会释放锁,当其他线程调用 signal() 时,线程会重新获得锁并继续执行。

         signal()用于唤醒一个等待的线程

注意:

        在调用 Condition 的 await()/signal()方法前,也需要线程持有相 关的 Lock 锁. 调用 await()后线程会释放这个锁,在 singal()调用后会从当前 Condition 对象的等待队列中,唤醒 一个线程,唤醒的线程尝试获得锁, 一旦获得锁成功就继续执行。

例子：创建两个Condition对象实现对指定锁的唤醒

public class Test9 {
    //创建可重入锁
   static Lock lock=new ReentrantLock();
   //创建两个condition对象
   static Condition conditionA=lock.newCondition();
   static Condition conditionB=lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Test9 t9=new Test9();
        //创建2个线程分别调用 waitA() waitB()
        new Thread(new Runnable() {
            @Override
            public void run() {
                t9.waitA();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t9.waitB();
            }
        }).start();
        //main休眠4秒
        Thread.sleep(4000);

        //释放线程A，注意 必须得获得锁才能使用 conditionA.signal();，不不然会产生异常
        lock.lock();
        System.out.println("释放线程A");
        conditionA.signal();
        lock.unlock();
        
        //释放线程B
        lock.lock();
        System.out.println("释放线程B");
        conditionB.signal();
        lock.unlock();



    }

    //创建让线程A等待的方法
    public void waitA(){
        try {
            lock.lock();
            //conditionA利用await()让A线程等待
            System.out.println(Thread.currentThread().getName()+"进入等待状态");
            conditionA.await();
            System.out.println(Thread.currentThread().getName()+"被释放");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    //创建让线程B等待的方法
    public void waitB(){
        try {
            lock.lock();
            //conditionB利用await()让B线程等待
            System.out.println(Thread.currentThread().getName()+"进入等待状态");
            conditionB.await();
            System.out.println(Thread.currentThread().getName()+"被释放");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

}

结果： 这里的Thread-0 是线程A  Thread-1是线程B

 注意  必须得获得与conditionA.await()的同一把锁,才能使用 conditionA.signal();，不不然会产生异常 ：

 

 结果：

1.2.7  公平锁与非公平锁

        大多数情况下,锁的申请都是非公平的， 如果线程1与线程2都在请求 锁 A， 当锁 A 可用时, 系统只是会从阻塞队列中随机的选择一个线程, 不能保证其公平性， 公平的锁会按照时间先后顺序,保证先到先得, 公平锁的这一特点不会出现线程饥饿现象。

        synchronized 内部锁就是非公平的。

        ReentrantLock 重入锁提供了一个 构造方法:ReentrantLock(boolean fair) ,当在创建锁对象时实参传递 true 可以把该锁设置为公平锁.。公平锁看起来很公平,但是要实现公平锁必须要求系统维护一个有序队列,公平锁的实现成本较高,性能也低. 因此默认情况下锁是非公平的. 不是特别的需求,一般不使用公平锁。

公平锁与非公平锁的线程线程运行对比：

不公平锁的情况：

public class Test7 {
    static Lock lock=new ReentrantLock();
    static int num=0;

    public static void main(String[] args) {
        MyRunnable1 myRunnable1=new MyRunnable1();
        Thread t1=new Thread(myRunnable1);
        Thread t2=new Thread(myRunnable1);
        Thread t3=new Thread(myRunnable1);
        Thread t4=new Thread(myRunnable1);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }

    public void doThing(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"开始工作...."+(++num));


            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

    }

    static class MyRunnable1 implements Runnable{
        Test7 t7=new Test7();
        
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                t7.doThing();
            }

        }
    }


 }

结果：有的线程还没工作完 别的线程就把锁抢占了，因为在cpu中获得锁的情况是随机的，不公平的

 

 公平锁的情况：在创建Lock的时候加入   true  即可

 结果：

 每个线程都可以公平的获得锁的机会，不存在有的线程有优先级的情况，是比较公平的

1.2.8  ReentrantLock自己的几个常用的方法

int getHoldCount() 返回当前线程调用 lock()方法的次数

int getQueueLength() 返回正等待获得锁的线程预估数

int getWaitQueueLength(Condition condition) 返回与 Condition 条件 相关的等待的线程预估数

boolean hasQueuedThread(Thread thread) 查询参数指定的线程是否 在等待获得锁

boolean hasQueuedThreads() 查询是否还有线程在等待获得该锁

boolean hasWaiters(Condition condition) 查询是否有线程正在等待 指定的 Condition 条件

boolean isFair() 判断是否为公平锁

boolean isHeldByCurrentThread() 判断当前线程是否持有该锁

boolean isLocked() 查询当前锁是否被线程持有

小北呱
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程学习 -中
小先生编程
10-25 127
在JDK5中增加了Lock锁接口，有ReentrantLock实现类，ReentrantLock锁称为可重入锁，它功能比synchronized 多。锁的可重入是指，当一个线程获得一个对象锁后，再次请求该对象锁时是可以获得该对象的锁的。 5.2 ReentrantLock 5.2.1 ReentrantLock 的基本使用 调用lock方法获得锁，调用unlock 方法释放锁。 使用lock锁同步不同方法中的同步代码块 ReentrantLock 锁的可重入性 lockInterruptibly() 方
Lock的使用（二）——使用ReentrantLock类
qq_44307209的博客
08-22 218
可以先对线程进行分组，然后再唤醒指定组中的线程。Object类中的 wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的wait()方法相当于Condition类中的await()方法。成功实现等待/通知模式。
java中ReentrantLock类的tryLock的标准例子和用法
及时雨的csdn
08-21 1748
package Lock; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockDemo { .
在Java中，tryLock(long time, TimeUnit unit)方法是用来在指定的时间内尝试获取锁的
最新发布
BLOG域名:programb.blog.csdn.net
04-22 975
它是一种显式锁，需要显式地创建锁对象，并在需要同步的代码块中使用lock()和unlock()方法来获取和释放锁。否则返回false。公平锁会按照线程请求锁的顺序来获取锁，而非公平锁则允许插队。锁的细粒度控制：ReentrantLock允许我们通过lock()和unlock()方法手动控制锁的获取和释放，这样可以更加灵活地控制锁的粒度，提高代码的性能。综上所述，synchronized关键字更常用于简单的线程同步需求，而ReentrantLock更常用于复杂的线程同步需求或者对锁的控制更加精细的场景。
Java面试题12-ReentrantLock中tryLock和lock方法的区别
z318913的博客
09-01 883
ReentrantLock中tryLock和lock方法的区别
java中ReentrantLock类的tryLock和tryLock的例子和用法
qq_43650923的博客
09-22 2055
ReentrantLock类的tryLock和tryLock(时间) tryLock的方法就是试一下，如果能得到锁，就返回真，如果当时得不到，马上就返回假，绝不等。tryLock(时间)的用法就是 在规定的时间内设法得到锁。如果在规定的时间内最终不能得到锁，就返回假。注意，这个方法是可以被打断的，打断后的处理方法和上面的例子 lockInterruptibly的处理一样。 例1.9.8_a: ...
Java源码解析之可重入锁ReentrantLock
08-26
Java源码解析之可重入锁ReentrantLock ReentrantLock是一个可重入锁，在ConcurrentHashMap中使用了ReentrantLock。它是一个可重入的排他锁，它和synchronized的方法和代码有着相同的行为和语义，但有更多的功能。 ...
详解java并发之重入锁-ReentrantLock
08-26
ReentrantLock 是 Java 中的一种常用锁机制，它提供了一个可重入的锁机制，能够确保线程安全。下面我们将详细介绍 ReentrantLock 的使用和实现原理。 一、ReentrantLock 的构造方法 ReentrantLock 提供了两个构造...
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
Java多线程中Lock锁的使用总结
08-18
ReentrantLock是一种可重入锁，允许多个线程重复获取同一个锁。ReentrantLock的优点是可以实现高效的锁机制，但是需要注意锁的释放问题。 知识点6: Java中的Condition接口 Java中的Condition接口是用于实现条件...
Java并发编程02:可重入锁ReentrantLock
ncepu_Chen的博客
07-11 856
Java并发编程02:可重入锁ReentrantLock可重入锁`ReentrantLock``ReentrantLock`的使用`ReentrantLock`获取锁的方法尝试锁`tryLock()`可中断锁`lockInterruptibly`公平锁等待/通知(await/signal)机制`await()`和`signal()`方法理解`Condition`对象使用`Condition`对象实...
Java并发编程(十三)：ReentrantLock-tryLock(long timeout, TimeUnit unit)源码分析
黄智霖的博客
04-12 1946
在前文ReentrantLock-NonfairSync源码逐行深度分析中，已经分析了AQS加解锁，阻塞唤醒与CLH队列的使用，这里主要看看带超时时间的tryLock实现。 在ReentrantLock的tryLock(timeout)方法中调用的是sync的tryAcquireNanos： public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return
Java多线程（二）——ReentrantLock源码解析（补充3——tryLock(long,TimeUnit) 锁超时）
深海流浪汉
01-23 1857
ReentrantLock的tryLock(long, TimeUnit)：如果在限定时间内没有获取到锁，将会放弃锁资源的等待。同时在限定时间内也可以响应中断。
Lock的tryLock(long time, TimeUnit unit)方法
松门一枝花
11-21 1万+
概述 tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。 代码 @Test public void testTryLock2() throws Exception
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3117
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
JavaScript中 Window Location的使用
weixin_46995731的博客
11-19 601
JavaScript中 Window Location的使用 window.location 对象用于获得当前页面的地址 (URL)，并把浏览器重定向到新的页面。 window.location 对象在编写时可不使用 window 这个前缀。 一些例子： 一些实例: location.hostname 返回 web 主机的域名 location.pathname 返回当前页面的路径和文件名 location.port 返回 web 主机的端口 （80 或 443） location.protocol 返回
ReentrantLock的lock(), tryLock(), tryLock(long timeout, TimeUnit unit), lockInterruptibly() 及使用场景示例
热门推荐
michaelgo的博客
08-07 2万+
一直在用concurrent包里的东西，最近想研究一下个中细节，先从ReentrantLock提供的集中获取锁的方式开始吧。 1.ReentrantLock简要介绍 简单介绍一下ReentrantLock，可重入锁，互斥锁，提供了fair和unfair两种模式的锁。默认构造函数是unfair的锁，如果初始化时传入true的参数则会返回fair锁。所谓不公平就是在锁可获取时，不用考虑该锁队列是否...
详解Java多线程tryLock()方法使用
fmz2222的博客
03-24 1584
tryLock()仅在调用时锁定未被其他线程持有的锁，如果调用方法时，锁对象对其他线程持有，则放弃，调用方法尝试获得没，如果该锁没有被其他线程占用则返回真实的表示锁定成功；tryLock(长时间，时间单位单位)的作用在给定等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断，则获得该锁，通过该方法可以实现锁对象的限时等待。//假设线程-0线程先持有锁，完成任务需要四秒钟，线程一线程尝试获得锁，线程一线程在3秒内还没有获得锁的话，线程一线程会放弃。当前线程().getName()'没有获得锁');
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
Java 5.0引入了`java.util.concurrent.locks`包中的`Lock`接口，提供了一种更细粒度、可中断、可重入的锁机制，相比`synchronized`关键字，`Lock`提供了更多的灵活性和控制能力。以下是一些`Lock`的特性： - **非...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值