03多线程常见锁

最新推荐文章于 2025-07-10 23:49:41 发布
原创 最新推荐文章于 2025-07-10 23:49:41 发布 · 3.3k 阅读 · 32 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #juc

本文探讨了公平锁与非公平锁的区别，解释了ReentrantLock的公平模式，并介绍了可重入锁、自旋锁和读写锁在并发编程中的应用，如synchronized和ReentrantReadWriteLock的使用示例。了解这些概念有助于提高多线程程序的效率和正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1公平锁、非公平锁 

概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象
区别：公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队列，则直接占有锁，否则插⼊到等待队列，FIFO原则。
非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采⽤公平锁方式。非公平锁的优点是吞吐量比公平锁更大。
synchronized 和 juc.ReentrantLock 默认都是非公平锁。ReentrantLock 在构造的时候传入 true则是公平锁。

private final ReentrantLock lock = new ReentrantLock(true);//公平锁

private final ReentrantLock lock = new ReentrantLock(false);//非公平锁

查看ReentrantLock源码的构造方法 默认是非公平锁

使用方法为：

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

2可重入锁、递归锁

可重入锁又叫递归锁，指的同⼀个线程在外层方法获得锁时，进入内层方法会自动获取锁。也就是说，线程可以进⼊任何⼀个它已经拥有锁的代码块。比如method01方法里面有 method02 方法，两个方法都有同⼀把锁，得到了method01的锁，就自动得到了method02的锁。就像有了家门的锁，厕所、书房、厨房就为你敞开了⼀样。可重⼊锁可以避免死锁的问题。

public synchronized void method1(){
    method2();
}

public synchronized void method2() {
}

 synchronized 和 ReentrantLock()默认支持可重入锁

2.1使用synchronized

/**
 * 可重入锁
 */
class PhonePlus {
    public synchronized void sendEmail(){
        System.out.println(Thread.currentThread().getName()+"=====sendEmail.....");
        sendMessage();
    }

    public synchronized void sendMessage(){
        System.out.println(Thread.currentThread().getName()+"=====sendMessage....");
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        PhonePlus phonePlus = new PhonePlus();
        new Thread(()->{
            phonePlus.sendEmail();
        }, "A").start();

        new Thread(()->{
            phonePlus.sendEmail();
        }, "B").start();
    }
}

 

2.2 使用ReentrantLock();

class PhonePlus {
    Lock lock = new ReentrantLock();
    public void method01(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"=====method01.....");
            method02();
        } finally {
            lock.unlock();
        }
    }

    public void method02(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"=====method02.....");
        } finally {
            lock.unlock();
        }
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        PhonePlus phonePlus = new PhonePlus();
        new Thread(()->{
            phonePlus.method01();
        }, "A").start();
        new Thread(()->{
            phonePlus.method01();
        }, "B").start();
    }
}

 

2.3验证内层方法是否获得锁

public void method02(){//去掉同步锁
    System.out.println(Thread.currentThread().getName()+"=====method02.....");
}
for (int i = 0; i < 100; i++) {//创建100线程实现高并发
    new Thread(()->{
        phonePlus.method01();
    }, i+"").start();
}

从运行结果看 method02()不加同步锁，也不会出现并发问题

3自旋锁 

所谓自旋锁，就是尝试获取锁的线程不会立即阻塞，而是采⽤循环的方式去尝试获取。自己在那儿一直循环获取，就像“自旋”⼀样。这样的好处是减少线程切换的上下文开销，缺点是会消耗CPU。CAS底层的 getAndAddInt 就是自旋锁思想

//跟CAS类似，⼀直循环比较。

while (!atomicReference.compareAndSet(null, thread)) { }

3.1CAS 比较并交换

CAS的全称为Compare-And-Swap，比较并交换，是⼀种很重要的同步思想。它是⼀条CPU并发原语。

它的功能是判断主内存某个位置的值是否为跟期望值⼀样，相同就进行修改，否则⼀直重试，直到⼀致为止。这个过程是原子的。

public static void main(String[] args) {
    AtomicInteger atomicInteger = new AtomicInteger(5);
    System.out.println(atomicInteger.compareAndSet(5, 2000) +"\t 当前数据值:" + atomicInteger.get());
    //修改
    System.out.println(atomicInteger.compareAndSet(5, 1000) +"\t 当前数据值:" + atomicInteger.get());
}

参考以前博客代码：01volatile关键字 的2.2原子性例子

查看AtomicInteger.getAndIncrement()源码

getAndAddInt()采用的是自旋锁的方式，while()判断条件内会判断共享内存中是否跟期望值相同，相同则进入循环体

3.2自旋锁实例代码：

/**
 * 自旋锁
 */
class WC {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    //锁门
    public void lock() {
        Thread currentThread = Thread.currentThread();
        //判断当前wc中 是否有人使用
        while(!atomicReference.compareAndSet(null, currentThread)){
            System.out.println(Thread.currentThread().getName()+"等待进入中===");
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace(); }
        }
        System.out.println(Thread.currentThread().getName()+"====在卫生间中...");
    }

    //开门
    public void unlock() {
        Thread currentThread = Thread.currentThread();
        atomicReference.compareAndSet(currentThread, null);
        System.out.println(currentThread.getName()+"=====unlock...");
    }
}

public class SpinLockDemo {
    public static void main(String[] args) {
        WC wc = new WC();
        new Thread(()->{
            wc.lock();//锁门
            try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) {e.printStackTrace(); }
            wc.unlock();//开门
        }, "AA").start();
        new Thread(()->{
            wc.lock();//锁门
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {e.printStackTrace(); }
            wc.unlock();//开门
        }, "BB").start();
    }
}

 

 自旋锁好处：循环比较获取直到成功为⽌，没有类似wait的阻塞。

通过CAS操作完成⾃旋锁，A线程先进来调⽤lock方法自己持有锁5秒钟，B随后进来后发现当前有线程持有锁，不是null，所以只能通过⾃旋等待，直到A释放锁后B随后抢到。

4读写锁

读锁是共享的，写锁是独占的。 juc.ReentrantLock 和 synchronized 都是独占锁，独占锁就是⼀个

锁只能被⼀个线程所持有。有的时候，需要读写分离，那么就要引⼊读写锁，即 juc.ReentrantReadWriteLock 。

独占锁：指该锁⼀次只能被⼀个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可被多个线程所持有

对ReenntrantReadWriteLock其读锁是共享锁，其写锁是独占锁。

读锁的共享锁可保证并发读是⾮常⾼效的，读写、写读、写写的过程是互斥的。

比如缓存，就需要读写锁来控制。缓存就是⼀个键值对，以下Demo模拟了缓存的读写操作，读的 get⽅法使⽤了 ReentrantReadWriteLock.ReadLock() ，写的 put ⽅法使⽤了ReentrantReadWriteLock.WriteLock() 。这样避免了写被打断，实现了多个线程同时读。

实例代码：

/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是，如果有一个线程想去写共享资料，就不应该再有其他线程可以对该资源进行读或写
 * 小总结：
 * 		读-读 能共存
 * 		读-写 不能共存
 * 		写-写 不能共存
 */
class Cache {
    private Map<String, Object> map = new ConcurrentHashMap<>();

    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 记录哪个线程来 签字
     * @param key 线程名
     * @param value 签字内容
     */
    public void put(String key, Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(key+"====正在签字: "+ value);
            //耗时操作
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace(); }
            map.put(key, value);
            System.out.println("===签字完成===");
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    /**
     * 获取指定线程 对应的value
     * @param key 线程名
     * @return 签字内容
     */
    public Object get(String key){
        Object result = null;
        readWriteLock.readLock().lock();
        try {
            System.out.println(key + "====正在看大家的签字:");
            //耗时操作
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace(); }
            result = map.get(key);
            System.out.println(key+"===看完了===");
        } finally {
            readWriteLock.readLock().unlock();
        }
        return result;
    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        Cache cache = new Cache();
        //写
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.put("线程名"+temp, "数据"+temp);
            }, String.valueOf(i)).start();
        }
        //读
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.get("线程名"+temp);
            }, String.valueOf(i)).start();
        }
    }
}

运行结果：写入数据环节是同步，阻塞访问

 读取数据环节是支持并发访问的

可以运行看下效果，因不能上传运行结果视频 ，需要自己手动运行理解一下：读-读 能共存，读-写 不能共存，写-写 不能共存的概念

多线程基础——锁
城南孔乙己的专栏
11-04 2350
线程安全是程序设计中的术语，指某个函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的全局变量，使程序功能正确完成。 假设有间银行只有 1000 元，而两个人同时提领 1000 元时就可能会拿到总计 2000 元的金额。为了避免这个问题，该间银行提款时应该使用互斥锁，即意味着针对同一个资源处理时，前一个人提领交易完成后才处理下一笔交易。但这种手法会使得效能降低。 线程安全的函数一般不应该修改全局对象。 锁的概念 在计算机科学中，锁是在执行多线程时用于强行限制资源访问的同步机制，即
多线程编程全攻略：提升性能与线程安全的必备知识
热门推荐
张彦峰的博客
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
多线程有哪些锁
TABE_的博客
08-26 2247
互斥锁是一种「独占锁」，比如当线程 A 加锁成功后，此时互斥锁已经被线程 A 独占了，只要线程 A 没有释放手中的锁，线程 B 加锁就会失败，于是就会释放 CPU 让给其他线程，既然线程 B 释放掉了 CPU，自然线程 B 加锁的代码就会被阻塞。自旋锁开销少，在多核系统下一般不会主动产生线程切换，但如果被锁住的代码执行时间过长，自旋的线程会长时间占用 CPU 资源，所以自旋的时间和被锁住的代码执行的时间是成「正比」的关系，我们需要清楚的知道这一点。互斥锁虽然简化了使用锁的难度，但是存在一定的性能开销，...
多线程中的锁
最新发布
2401_88195314的博客
07-10 224
在 Java 里，Lock是一个接口，它位于包下，是对传统关键字的扩展，能实现更灵活的锁操作。下面为你大概的介绍它：1.lock和unlocklock()unlock()2.关键字在 Java 中，关键字是用于实现线程同步的核心机制，它确保同一时间只有一个线程可以执行被保护的代码块或方法，从而避免多线程竞争导致的数据不一致问题。其特点：1.锁默认打开，有一个线程进去，锁自动关闭2.里面的代码全部执行完毕，线程出来，锁自动打开特别注意：死锁死锁是多线程或多进程环境中可能出现的一种严重问题。
【多线程】锁的类型
wangweixaut061的专栏
02-29 4236
锁的类型 根据完成任务所需要的 结构不同，一个应用程序可能会使用多种不同类型的锁原语，因此，开发人员必须避免在一个给定任务中混淆这些锁原语，尤其在使用第三方提供的库时需要格外小 心。假设在一个应用程序中，资源R依赖于第三方提供的库，并且在该库中资源R使用L型锁作为同步原语。此时， 若开发者需要在应用程序中对资源R使用锁原语，则必须也使用L而不是其他类型的锁原语。接下来的部分将介绍不同类型的锁，并
【多线程】常见的锁策略
耀的博客
03-12 2491
一、乐观锁与悲观锁 举个栗子: 同学 A 和 同学 B 想请教老师一个问题. 同学 A 认为 "老师是比较忙的, 我来问问题, 老师不一定有空解答". 因此同学 A 会先给老师发消息: "老师 你忙嘛? 我下午两点能来找你问个问题嘛?" (相当于加锁操作) 得到肯定的答复之后, 才会真的来问问题. 如果得到了否定的答复, 那就等一段时间, 下次再来和老师确定时间. 这个是悲观锁 同学 B 认为 "老师是比较闲的, 我来问问题, 老师大概率是有空解答的". 因此同学 B 直接就来找老师.(没 加锁, 直
12【多线程、锁机制、lock锁】
緑水長流*z
08-05 4536
一、多线程概念 我们之前在进行程序设计时，程序都是由上往下依次执行，无法让多个应用程序同时执行。不管是我们电脑上还是手机中的应用程序，我们都可以让多个应用程序同时执行。例如一边运行QQ，一边运行酷狗音乐。打开QQ时一边聊天，又一边上传群文件，还一边下载群文件，同时与多个人聊天等。要使得我们的程序能够同时运行多个应用程序就需要使用到多线程/多进程的知识了； 1.1 程序的并发与并行 1.1.1 程序的并行 程序的并行指的是多个应用程序真正意义上的同时执行，CPU分配多个执行单元共同执行这些任务，效率高，但这依
Java多线程（03）—— 锁策略与锁升级
2201_75456895的博客
05-29 1265
锁的策略是指：在加锁过程中，处理锁冲突的时候的处理方式；
Python 多线程与锁：原理、应用与实践
srlsong的博客
07-07 984
本文介绍了Python多线程编程的基础知识及其锁机制。首先阐述了多线程的概念，指出线程是程序执行的最小单元，Python通过threading模块实现多线程编程，适用于I/O密集型任务。其次详细讲解了锁机制的必要性和类型，包括互斥锁、递归锁和信号量，强调了它们对解决数据竞争问题的重要作用。最后提出了使用锁时的注意事项，如避免死锁、减少性能影响等。文章为开发者提供了Python多线程和锁技术的全面指导，有助于编写高效稳定的并发程序。
多线程间的几种锁
蓬莱道人的博客
12-13 3890
1、互斥量（互斥锁） 2、读写锁（共享互斥锁） 3、自旋锁 4、条件变量 5、屏障 1、互斥量（互斥锁） #include<pthread.h> // 初始化互斥量 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); // 销毁互斥量 int pthread_mutex_destroy(pthread_mutex_t *mut
多线程-锁的种类
weixin_46894136的博客
09-11 696
共享锁和排它锁多用于数据库中的事物操作，主要针对读和写的操作。自旋锁认为:如果持有锁的线程能在很短的时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞、挂起状态，只需等一等(也叫作自旋),在等待持有锁的线程释放锁后即可立即获取锁，这样就避免了用户线程在内核状态的切换上导致的锁时间消耗。锁从乐观和悲观的角度可分为乐观锁和悲观锁，从获取资源的公平性角度可分为公平锁和非公平锁，从是否共享资源的角度可分为共享锁和独占锁,从锁的状态的角度可分为偏向锁、轻量级锁和重量级锁。
多线程的锁
CoderLai的博客
07-14 733
多线程的锁
多线程—锁
hhhg1234的博客
04-20 2101
乐观锁 概念：它认为一般情况下不会发生并发冲突，所以只有在进行数据更新的时候，才会检测并发冲突，如果没有冲突，则直接修改，如果有冲突，则返回失败。 CAS机制 Compare and swap，是乐观锁的一种机制 当多个线程同时对某个资源进行CAS操作，只能有一个线程操作成功，但是并不会阻塞其他线程,其他线程只会收到操作失败的信号。CAS是一个乐观锁。 组成部分 V 内存值 A旧值 B新值 如果内存中的值等于旧值，则没有并发冲突，直接将新值带入到内存值即可 如果内存中的值不等于旧值，则进行自旋，将自己的内存
浅析多线程中的各种锁
wh柒八九的博客
04-18 1227
高并发的场景下，如果选对了合适的锁，则会大大提高系统的性能，否则性能会降低。所以，知道各种锁的开销，以及应用场景是很有必要的。 文章目录常用的各种锁 常用的各种锁
多线程的各种锁
蜡笔小明的博客
10-05 270
在学习多线程的时候，我们经常会听到可重入锁/不可重入锁、公平锁/非公平锁、读写锁现在我们就逐一它们的神秘面纱。 Lock包下的层级结构 1.可重入锁/非重入锁：大部分jdk提供的都是可重入锁，如syncronized,reentrantLock 都是可重入，代表单个（也可以说同一个）线程可以多次获得该锁，如果单个线程拿到锁没有释放，你再去拿，拿到则是重入锁 ，拿不到则是非...
java-锁的分类
aoshanshu6185的博客
09-01 168
锁的分类 自旋锁： 线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起。 阻塞锁：阻塞锁改变了线程的运行状态，让线程进入阻塞状态进行等待，当获得相应的信号（唤醒或者时间）时，才可以进入线程的准备就绪状态，转为就绪状态的所有线程，通过竞争，进入运行状态...
18.多线程中的锁有哪一些？
daohangtaiqian的博客
05-11 1081
根据分类标准我们把锁分为以下 7 大类别，分别是：偏向锁/轻量级锁/重量级锁；可重入锁/非可重入锁；共享锁/独占锁；公平锁/非公平锁；悲观锁/乐观锁；自旋锁/非自旋锁；可中断锁/不可中断锁。以上基本是我们经常会遇到的一些锁。
java多线程常见的锁
11-30
在 Java 中，多线程编程时可能会遇到共享资源竞争的问题，这可能导致数据不一致性和并发错误。为了解决这些问题，Java 提供了多种同步机制，其中最常见的几种锁包括： 1. **synchronized 关键字**：这是最基本的同步原语，当一个方法或代码块被 synchronized 修饰时，只有一个线程可以访问该代码。它会自动获取并释放当前对象的监视锁（monitor），即对象内部的 `this` 对象。 2. **ReentrantLock**：这是一个更高级别的互斥锁，提供了比 synchronized 更强的控制力。它允许显式地获取、释放锁，以及检查锁是否已被持有，这对于复杂的同步场景非常有用。 3. **Semaphore**：信号量是一种计数器，用于限制同时访问特定资源的线程数量。它允许多个线程通过，但只有当信号量剩余许可数大于0时。 4. **CountDownLatch** 和 **CyclicBarrier**：这两个类主要用于线程间的协作，CountDownLatch 有一个倒计时器，所有等待它的线程需要等到倒计时结束后才能继续；而 CyclicBarrier 允许一组线程到达某个屏障点后一起继续执行。 5. **Atomic 类型**：如 AtomicInteger 和 AtomicLong 等原子变量提供了一种无需锁就能安全更新值的方式，适用于简单的线程安全操作。 6. **ThreadLocal**：这是一种作用于当前线程的局部变量，每个线程都有自己的 ThreadLocal 变量副本，彼此之间不会相互干扰。 了解和合理使用这些锁对于编写健壮的并发程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值