Java并发编程学习（四）—— Lock

amurocrash amurocrash 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 377平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄17年
关注
原创 最新推荐文章于 2026-04-18 10:31:20 发布 377 阅读 AI 写同款· GEO 优化 ›
（Redis使用系列） Springboot 整合Redisson 实现分布式锁 七 前言 该篇是基于springboot 项目整合 Redisson 实现对redis的操作。 内容： 1.使用RedissonClient对一些集合的常规操作，数据查询，存储等； 2.以AOP方式实现分布式锁 正文 第一步： pom.xml 添加核心依赖包： <dependency> <groupId>org.springframework.boot</groupId> <... 阅读详情

一、ReentrantLock

1、Reentrant其实是ReEntrant，可重入的意思。先来个标准例子：

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample
{
    public static void main(String[] args)
    {
        A a = new A();

        for(int i = 0; i < 5; i ++)
        {
            Thread t = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    a.a();
                }

            });
            t.setName("t" + (i + 1));
            t.start();
        }
    }

    static class A
    {
        ReentrantLock lock = new ReentrantLock();

        void a()
        {
            lock.lock();

            String tName = Thread.currentThread().getName();
            for(int i = 0; i < 10; i++)
            {
                System.out.println(tName + " : " + (i + 1));
            }

            b();

            lock.unlock();
        }

        void b()
        {
            lock.lock();

            System.out.println("tName b");

            lock.unlock();
        }
    }
}

程序输出：
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t1 : 10
t1 b
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
t2 : 10
t2 b
t3 : 1
t3 : 2
t3 : 3
t3 : 4
t3 : 5
t3 : 6
t3 : 7
t3 : 8
t3 : 9
t3 : 10
t3 b
t4 : 1
t4 : 2
t4 : 3
t4 : 4
t4 : 5
t4 : 6
t4 : 7
t4 : 8
t4 : 9
t4 : 10
t4 b
t5 : 1
t5 : 2
t5 : 3
t5 : 4
t5 : 5
t5 : 6
t5 : 7
t5 : 8
t5 : 9
t5 : 10
t5 b
可以见这种情况下，lock的作用和synchronized的几乎一样，是一把可重入的锁。

2、condition/signal == wait/notify

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample
{
    public static void main(String[] args) throws Exception
    {
        final Service service = new Service();

        Thread t = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                service.await();
            }
        });
        t.start();

        Thread.sleep(3000);
        service.signal();
    }

    static class Service
    {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        void await()
        {
            try
            {
                lock.lock();
                System.out.println("await begin");
                condition.await();
                System.out.println("await end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void signal()
        {
            lock.lock();
            System.out.println("signal");
            condition.signal();
            lock.unlock();

        }
    }
}

程序输出：
await begin
signal
await end

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample
{
    public static void main(String[] args) throws Exception
    {
        final Service service = new Service();

        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                service.await1();

            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                service.await2();
            }
        });
        t2.start();

        Thread.sleep(3000);
        service.signal();
    }

    static class Service
    {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        void await1()
        {
            try
            {
                lock.lock();
                System.out.println("await1 begin");
                condition.await();
                System.out.println("await1 end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void await2()
        {
            try
            {
                lock.lock();
                System.out.println("await2 begin");
                condition.await();
                System.out.println("await2 end");
            }
            catch (Exception e) 
            {
            }
            finally
            {
                lock.unlock();
            }
        }

        void signal()
        {
            lock.lock();
            System.out.println("signal");
            condition.signalAll();
            lock.unlock();

        }
    }
}

程序输出：
await1 begin
await2 begin
signal
await1 end
await2 end

3、实现生产消费者模式

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class SinglePC
{
    public static void main(String[] args)
    {
        P p = new P();
        C c = new C();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    p.set();
                }
            }
        }).start();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    c.get();
                }
            }
        }).start();


    }

    static String value = "";
    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    static class P
    {


        void set()
        {
            try
            {
                lock.lock();

                while(!"".equals(value))
                {
                    condition.await();
                }

                System.out.println("empty");
                value = "Double X";
                Thread.sleep(2000);
                condition.signal();

            }
            catch (Exception e) 
            {

            }
            finally
            {
                lock.unlock();
            }
        }
    }

    static class C
    {
        void get()
        {
            try
            {
                lock.lock();

                while("".equals(value))
                {
                    condition.await();
                }

                System.out.println(value);
                value = "";
                Thread.sleep(2000);
                condition.signal();

            }
            catch (Exception e) 
            {

            }
            finally
            {
                lock.unlock();
            }
        }
    }
}

4、公平锁与非公平锁
公平锁：线程获取锁的顺序遵循先到先得；
非公平锁：非先到先得，可能导致某些线程一直拿不到锁。
创建方法：

ReentrantLock lock = new ReentrantLock(true);//fair
ReentrantLock lock = new ReentrantLock(false);//unfair

5、lock的常用方法
1）int getHoldCount
当前线程保持此锁定的个数，也就是调用lock方法的次数。

2）int getQueueLength()
等待获取此lock的线程数，比如5个线程争夺一个lock，当1个线程获得lock后执行了sleep方法，此时调用getQueueLength方法返回的结果为4。

3）int getWaitQueueLength()
5个线程，每个线程都执行了同一个condition的await方法，则调用此方法返回5。

4）boolean hasQueueThread(thread)和bolean hasQueueThreads()
查询指定线程是否在等待获取锁；
查询是否有线程在等待获取锁。

5）boolean hasWaiters(condition)
查询是否有线程在用当前condition进行等待。

6）boolean isFair()
查询是否公平锁。

7）boolean isHeldByCurrentThread()和boolean isLocked()
查询当前线程是否获得了锁。
查询是否有线程了获得了锁。

8）void lockInterruptibly()
不太好解释，先看代码：

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.ReentrantLock;

public class LockInterruptibly
{
    public static void main(String[] args) throws Exception
    {
        final Service s = new Service();
        Thread tA = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                s.invoke();
            }
        });
        tA.start();
        Thread.sleep(500);

        Thread tB = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                s.invoke();
            }
        });
        tB.start();

        tB.interrupt();
        System.out.println("main end");
    }

    static class Service
    {
        private ReentrantLock lock;

        public Service()
        {
            lock = new ReentrantLock();
        }

        void invoke()
        {
            try
            {
                lock.lock();
//              lock.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + " begin");

                for(int i = 0; i < Integer.MAX_VALUE / 10; i++)
                {
                    String str = new String();
                    Math.random();
                }   

                System.out.println(Thread.currentThread().getName() + " end");
            }
            catch (Exception e) 
            {
                System.out.println(Thread.currentThread().getName() + " goes into exception " + e.getMessage());
            }
            finally
            {
                if(lock.isHeldByCurrentThread())
                {
                    lock.unlock();
                }
            }
        }
    }
}

当使用lock.lock()时，打印结果为：
Thread-0 begin
main end
Thread-0 end
Thread-1 begin
Thread-1 end
当使用lock.lockInterruptibly时，打印结果为：
Thread-0 begin
main end
Thread-1 goes into exception null
Thread-0 end

由此可见，lockInterruptibly方法的意义是：如果线程未被中断（调用interrupt方法）时，可以正常获取锁，如果已经被中断则抛出异常。

9）boolean tryLock()
这个方法最大的好处就是发现拿不到锁的时候，可以进行其他处理。方法会直接返回false。

10）void awaitUninterruptibly()
正常情况下，在condition.await的时候调用线程的interrupt方法会导致抛出异常，但是如果使用awaitUninterruptibly方法，就不会抛出异常，程序会继续等待signal。

11）void awaitUtil(Date)

package com.amuro.studythread;

import java.util.Calendar;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test
{
    public static void main(String[] args) throws Exception
    {
        final Test t = new Test();
        Thread th = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                t.invoke();
            }
        });
        th.start();

        Thread.sleep(1000);
        t.signal();
    }

    ReentrantLock lock;
    Condition condition;

    public Test()
    {
        lock = new ReentrantLock();
        condition = lock.newCondition();
    }

    void invoke()
    {
        try
        {
            Calendar c = Calendar.getInstance();
            c.add(Calendar.SECOND, 3);
            lock.lock();
            System.out.println("begin");
            condition.awaitUntil(c.getTime());
            System.out.println("end");
        } 
        catch(Exception e)
        {
            System.out.println("exception: " + e.getMessage());
        }
        finally
        {
            lock.unlock();
        }
    }

    void signal()
    {
        try
        {
            lock.lock();
            condition.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

线程会一直等待到传入的时间，但是可以被signal提前打断。

6、condition实现线程的顺序执行

package com.amuro.studythread.chapter4_lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class SequenceThreadInvoke
{
    static int go = 1;

    public static void main(String[] args)
    {
        final ReentrantLock lock = new ReentrantLock();
        final Condition condition = lock.newCondition();
        int length = 5;

        for(int i = 0; i < length; i++)
        {
            MyThread t = new MyThread(i + 1)
            {
                @Override
                public void run()
                {
                    while(true)
                    {
                        try
                        {
                            lock.lock();
                            while(go != getI())
                            {
                                condition.await();
                            }

                            System.out.println(getI());
                            if(go == length)
                            {
                                go = 1;
                            }
                            else
                            {
                                go++;
                            }
                            Thread.sleep(1000);
                            condition.signalAll();
                        }
                        catch (Exception e) 
                        {

                        }
                        finally
                        {
                            lock.unlock();
                        }
                    }
                }
            };
            t.start();
        }

    }

    static class MyThread extends Thread
    {
        int i;

        public MyThread(int i)
        {
            super();
            this.i = i;
        }

        public int getI()
        {
            return i;
        }
    }
}

二、ReentrantReadWriteLock

1、概念
ReentrantLock和synchronized都有天然的缺陷就是同一时间只能有一个线程获得锁，虽然保证了线程安全，但是效率极其低下。所以java又提供了读写锁，其中读锁是共享锁，在没有线程进行写入操作时，多个线程可以同时获得读锁；但是同一时刻只允许一个线程进行写操作。

2、读读共享，写写互斥

package com.amuro.studythread.chapter4_lock;

import java.util.Date;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class WRLockExample1
{
    public static void main(String[] args) throws Exception
    {
        final File file = new File();
        for(int i = 0; i < 10; i++)
        {
            new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    file.read();
                }
            }).start();
        }

        Thread.sleep(2000);

        for(int i = 0; i < 10; i++)
        {
            new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    file.write();
                }
            }).start();
        }
    }

    static class File
    {
        ReentrantReadWriteLock wrLock;

        public File()
        {
            wrLock = new ReentrantReadWriteLock();
        }

        void read()
        {
            try
            {
                wrLock.readLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get read lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);
            }
            catch (Exception e) 
            {

            }
            finally
            {
                wrLock.readLock().unlock();
            }
        }

        void write()
        {
            try
            {
                wrLock.writeLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get write lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);

            }
            catch(Exception e)
            {

            }
            finally
            {
                wrLock.writeLock().unlock();
            }
        }
    }

}

程序输出：
Thread-7 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-9 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-3 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-0 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-2 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-1 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-8 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-4 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-5 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-6 get read lock on Wed Jan 03 10:47:52 CST 2018
Thread-10 get write lock on Wed Jan 03 10:47:54 CST 2018
Thread-12 get write lock on Wed Jan 03 10:47:55 CST 2018
Thread-11 get write lock on Wed Jan 03 10:47:56 CST 2018
Thread-13 get write lock on Wed Jan 03 10:47:57 CST 2018
Thread-14 get write lock on Wed Jan 03 10:47:58 CST 2018
Thread-15 get write lock on Wed Jan 03 10:47:59 CST 2018
Thread-16 get write lock on Wed Jan 03 10:48:00 CST 2018
Thread-17 get write lock on Wed Jan 03 10:48:01 CST 2018
Thread-18 get write lock on Wed Jan 03 10:48:02 CST 2018
Thread-19 get write lock on Wed Jan 03 10:48:03 CST 2018
这个很好理解，不多说了；

3、读写互斥，写读互斥

package com.amuro.studythread.chapter4_lock;

import java.util.Date;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class WRLockExample2
{
    public static void main(String[] args) throws Exception
    {
        final File file = new File();
        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                file.read();

            }
        }).start();

        new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                file.write();
            }
        }).start();
    }

    static class File
    {
        ReentrantReadWriteLock wrLock;

        public File()
        {
            wrLock = new ReentrantReadWriteLock();
        }

        void read()
        {
            try
            {
                wrLock.readLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get read lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(5000);
            }
            catch (Exception e) 
            {

            }
            finally
            {
                wrLock.readLock().unlock();
            }
        }

        void write()
        {
            try
            {
                wrLock.writeLock().lock();
                System.out.println(
                        Thread.currentThread().getName() + 
                        " get write lock on " + 
                        new Date(System.currentTimeMillis()));
                Thread.sleep(1000);

            }
            catch(Exception e)
            {

            }
            finally
            {
                wrLock.writeLock().unlock();
            }
        }
    }

}

程序输出：
Thread-0 get read lock on Wed Jan 03 11:05:47 CST 2018
Thread-1 get write lock on Wed Jan 03 11:05:52 CST 2018
可见当一个读写锁之间是互斥的，在读锁或者写锁没有unlock时，无法获得另一种锁。

收录于
读书笔记

当前文章被收录于：

读书笔记
14 篇文章 0 人学习
订阅专栏 查看详情
标签
#java #并发 #编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
AP发票批量付款程序（WEB ADI） CREATE OR REPLACE PACKAGE MEW_AP_BATCH_PAYMENTS_PKG IS   PROCEDURE MAIN(P_BATCH_ID          NUMBER                 ,P_ORG_ID            NUMBER                 ,P_BANK_ACCOUNT_NAME VARCHAR2 阅读详情

相关推荐

运动目标成像必学：5分钟搞懂keystone变换原理与避坑指南

本文深入浅出地解析了雷达信号处理中的Keystone变换原理，它是解决运动目标距离徙动问题的关键技术。文章通过直观比喻和简化公式，阐述了该变换如何通过变量代换实现距离与慢时间的解耦合，将倾斜轨迹“掰直”，从而提升成像与检测性能。同时，文中重点指出了实际应用中关于大速度场景、插值误差、多目标处理及高阶运动补偿等关键避坑点，为工程实践提供了宝贵指南。

ios99的博客 403

isrun java用法_Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别...

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！代码地址：https://github.com/xianzhixianzhixian/thread.git方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁的先后顺序来的，...

weixin_42134234的博客 826

嵌入式开发避坑指南：手把手教你用STM32CubeMX配置W9825G6KH SDRAM（含时序参数详解）

本文详细介绍了如何使用STM32CubeMX配置W9825G6KH SDRAM，包括硬件连接检查、CubeMX初始化步骤、时序参数优化及稳定性问题排查。通过实测波形分析和案例分享，帮助开发者避免常见配置错误，提升嵌入式系统性能与稳定性。

weixin_42542669的博客 197

Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git 方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别 1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁...

樊先知樊先知的博客 1万+

OpenResty无损升级内嵌nginx版本0DAY漏洞

OpenResty无损升级内嵌nginx版本，nginx

qq1071643762的博客 6904

rfid标签技术原理

奇怪的是，RFID标签技术原理的深入剖析不仅揭示了其背后的奥秘，也让我们更加全面地认识到这一技术在数字化转型中的重要性和潜力。随着技术的不断进步和应用场景的不断拓展，RFID标签将在更多领域发挥重要作用，为物联网、智能制造等领域的发展注入新的活力。这意味着在一个读写器的覆盖范围内，可以同时读取多个RFID标签的数据，大大提高了数据收集的速度和效率。：RFID标签的“大脑”，负责存储和处理数据。芯片内部集成了存储器、控制逻辑和射频接口等电路，能够接收来自读写器的射频信号，执行相应的数据处理和通信任务。

x3088的博客 2159

多线程编程第四章Lock的使用

使用ReentrantLock lock.lock();//此方法相当于上锁 lock.unlock();//此方法相当于释放锁 Condition condition = lock.newCondition(); condition.await();//相当于wait() condition.signal();//相当于nontify condition.signalAll();//相当于no...

孤竹彧的根据地 1523

人工智能在高中教育中的应用现状剖析与挑战应对

人工智能在高中教育中的应用现状剖析与挑战应对

燕鹏 1340

redisson的isHeldByCurrentThread的使用解释

在thread-1还没有结束的时候,也就是在thread-1在获得锁但是还没有释放锁的时候, `thread-2由于被别的线程中断停止了等待从lock.tryLock的阻塞状态中返回继续执行接下来的逻辑,并且由于尝试去释放一个属于线程thread-1的锁而抛出了一个运行时异常导致该线程thread-2结束了, 然而thread-2完成了一系列操作后,线程thread-1才释放了自己的锁. 所以thread-2并没有获得锁,却执行了需要同步的内容,还尝试去释放锁。那解决方式我们就知道了，当前线程加的锁由当前线

京北游戏官方 9415

【Qt笔记】1.VSCode搭建Qt运行环境

Qt6之后已经抛弃qmake，使用cmake。cmake相对qmake来说只有优点没有缺点。使用VSCode搭建完Qt的运行环境就能开开心心debug了.vscode需要使用的插件:2.Qt tools3.CMakec++插件可以不关注,缺啥都会提醒你.正常安装即可。

没有手牌的博客 2万+

Python爬虫实战：基于Scrapy与Playwright高效爬取人民网新闻数据

本文将详细介绍如何使用Python最新技术栈（Scrapy框架结合Playwright浏览器自动化工具）高效爬取人民网新闻数据。文章包含完整项目搭建、反反爬策略、数据解析存储以及性能优化等核心内容，提供可直接运行的代码示例，适合中高级Python开发者学习现代网络爬虫开发技术。python# 去除特殊空白字符。

2201_76125261的博客 1118

并发编程学习总结(四) ：java 显式锁ReentrantLock使用详解之lock()\unlock() 加锁与释放锁

在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果两个线程存取相同的对象，并且每一个线程都调用了一个修改该对象状态的方法，那么线程彼此踩了对方的脚，根据各线程访问数据的次序，可能会产生讹误的对象。这样的一种现象称之为竞争条件。 当然多个线程共享一个变量在实际的应用中有时难以避免，但是我们可以通过java提供的一些技术来避免线程彼此踩脚的行为发生。 java提供了

远方和诗 的博客 5730

MIKE水动力笔记2_水动力基础理论知识

本文所讲内容是水动力基础理论知识，所参考的主要书籍是《水动力学和水质》（第二版，季振刚著，海洋出版社）。

晏长街的博客 1万+

（二）深入并发编程之Lock锁

并发编程之Lock锁

qq_44816669的博客 1603

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件，这是C++版本的破解文件

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面，电脑运行连游戏界面都一样大小，很怀旧，很真实，（英文版）强烈推荐，很小的文件，很难才找到的。

Java并发编程之Lock

Lock是一个接口提供了无条件的、可轮询的、定时的、可中断的锁获取操作，所有加锁和解锁的方法都是显式的。 我们知道，synchronized是Java的关键字，是Java的内置特性，在JVM层面实现了对临界资源的同步互斥访问，但synchronized粒度有些大，在处理实际问题时存在诸多局限性，比如响应中断等。Lock提供了比synchronized更广泛的锁操作，它能以更优雅的方式处理线程同步

itmyhome的专栏 1189

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等，可在创建的窗口进行控制

Java并发编程四synchronized和lock

synchronized和locksynchronized为什么使用synchronized什么是synchronizedsynchronized机制synchronized使用场景synchronized锁升级偏向锁CAS轻量级锁锁的优缺点彻底搞懂锁升级lock使用方法AQS锁的介绍两者不同Condition接口 Java并发编程一 Java并发编程二 Java并发编程三 synchronize...

不正经开发的博客 1598

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册，内含HL7和ASTM)

Java并发编程：Lock接口

在实际开发中，应根据业务场景的并发特性（如读写比例、是否需要中断等）选择合适的锁实现，同时注意锁的释放（务必在 finally 中调用 unlock() ），避免死锁等问题。- 特性：支持重入（同一线程可多次获取锁，需对应次数释放），默认非公平锁（可通过构造函数指定 fair=true 实现公平锁）- 特性：分离读锁和写锁，允许多个读线程同时访问，写线程独占锁（读-读不互斥，读-写互斥，写-写互斥）- 功能：超时尝试获取锁，在指定时间内获取到锁返回 true ，超时则返回 false ，支持中断。

2503_90569120的博客 756

Java中synchronized与Lock的区别

***//***//***//***//***/}lock()：获取锁，如果锁被暂用则一直等待unlock():释放锁tryLock(): 注意返回类型是boolean，如果获取锁的时候锁被占用就返回false，否则返回truetryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个时间期限，保证等待参数时间。

Machine Learning with Tutors 1万+

【java并发编程】Lock接口

java显式锁：Lock接口 ​ JDK1.5开始引入显式锁，Lock与使用synchronized方法和语句相比，实现提供了更广泛的锁定操作。它们允许更灵活的结构，可以具有完全不同的属性。 1.接口说明 ​ Modifier and Type Method and Description void lock()Acquires the lock.（获取锁） void lock...

叁滴水 的博客 1534

Java 并发编程详解：Lock 接口及其实现 ReentrantLock

Lock接口 提供了比 synchronized 关键字更灵活和丰富的锁机制。是 Lock 接口的一个实现，支持可重入、可选择的公平锁以及提供 Condition 对象来实现复杂的线程间协调。使用 ReentrantLock 可以提高多线程环境下程序的并发性能和可控性，适用于需要复杂锁控制的场景。通过合理使用 Lock 接口及其实现 ReentrantLock，可以更有效地管理并发，确保线程安全，提高程序的可靠性和性能。

微笑听雨 6026

Java并发编程一Lock和ReentrantLock初使用

Java并发编程一Lock初使用 首先我们来演示一下两个线程不断的打印两个字符串。 代码 package lock.reentrantlock; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 描述： 演示ReentrantLock的基本用法，演示被打...

kaven 1218

Java并发编程：Lock

Java并发编程：Lock一.synchronized的缺陷二.java.util.concurrent.locks包下常用的类1.Lock2.ReentrantLock3.ReadWriteLock4.ReentrantReadWriteLock5.Lock和synchronized的选择三.锁的相关概念介绍1.可重入锁2.可中断锁3.公平锁4.读写锁 使用关键字synchronized能实现代码块的同步访问。从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式

李利科 279

【java并发编程】Lock & Condition 协调同步生产消费

一、协调生产/消费的需求 本文内容主要想向大家介绍一下Lock结合Condition的使用方法，为了更好的理解Lock锁与Condition锁信号，我们来手写一个ArrayBlockingQueue。 JDK实际上已经有这个类，基于Lock锁与Condition锁信号实现的，当然JDK实现代码很复杂包含了更严谨的逻辑校验，以及从性能优化的角度做了更多的工作。本文中我们只是来简单实现一下其核心逻辑： ArrayBlockingQueue初始化构造时指定容量上限最大值 提供put方法，当达到Queue队列容.

字母哥博客 1009

Java 并发编程：使用 Lock 和 Condition 实现线程同步

Lock和Condition接口是 Java 并发编程中非常重要的工具，它们为开发者提供了比synchronized更灵活、更强大的同步机制。通过合理使用Lock和Condition，可以实现复杂的同步控制、高效的线程间通信，从而提升程序的性能和稳定性。在实际开发中，应根据具体的业务场景和需求，选择合适的同步方式。同时，在使用Lock和Condition时，要注意正确地获取和释放锁，避免出现死锁等问题。随着 Java 版本的不断更新，并发编程的工具和技术也在不断发展和完善。

数字魔方操控师的博客 1149

JAVA并发编程 - Lock的底层原理

通过ReentrantLock源码来学习java lock加锁过程

qq_34949319的博客 2944
上一篇： Java并发编程学习（三）——线程通信
下一篇： 关于HashMap你要知道的事情
点赞 0
评论 0
书签 书签 0
amurocrash
amurocrash
博客等级 码龄17年 405粉丝 76原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值