JUC的那些同步锁们

最新推荐文章于 2024-05-25 12:01:51 发布
最新推荐文章于 2024-05-25 12:01:51 发布
阅读量329 收藏 2
点赞数 1
分类专栏： 多线程 文章标签： 多线程 java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szy2333/article/details/108885591
版权

JUC的那些同步锁们

Reentranlock

关于可重入锁，可以参考这一篇专门讲述的博文：聊聊关于Reentrantlock

ReadWriteLock

实际情况中，对于数据往往百分之80都是在进行读的操作，那么如果还使用互斥锁，即每个线程在执行的时候，其他线程只能等待，这样效率会非常低下，因此产生了ReadWriteLock(读写锁)。其中读锁是共享锁，写锁时排它锁（互斥锁），读写锁的本质是提高了读的效率。
如下代码：

public class ReadAndWrite {
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        for(int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                   //reentrantLock.lock();
                    readLock.lock();
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("read over！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //reentrantLock.unlock();
                    readLock.unlock();
                }
            }).start();
        }

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                try {
                    //reentrantLock.lock();
                    writeLock.lock();
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("write over~~~");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //reentrantLock.unlock();
                    writeLock.unlock();
                }
            }).start();
        }
    }
}

在使用普通锁时，十个读线程和两个写线程会依次执行，耗时12秒。当使用读写锁时，十个读线程几乎同时完成，然后两个写线程依次执行，耗时2秒。

CountDownLatch

CountDownLatch是一个同步工具类，它允许一个或者多个线程一直等待，直到其他线程执行完再执行

原理是通过一个计数器实现的，计数器的初始化值为线程的数量，每当一个线程完成来了自己的任务之后，计数器的值就相应减一。当计数器到达0时，表示所有线程都已完成任务，然后在闭锁上等待的线程就可以恢复执行任务。构造方法需要传一个count（int类型）参数，是用等待线程数量来进行初始化
计数器count是闭锁需要等待的线程数量，只能被设置一次，且CountDownLatch没有提供任何机制去重新设置计数器count，与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在其他线程启动后立即调用CountDownLatch.wait()，这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。其他线程必须引用CountDownLatch闭锁对象，因为它们需要通知CountDownLatch对象。这种通知机制是通过CountDownLatch.countDown()来完成的，每调用一次，count的值减一，因此其它线程都调用这个方法，直到count为0，主线程就可以通过await()恢复自己的任务
代码示例：

public class CountDownTest {
    static CountDownLatch latch = new CountDownLatch(5);

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName());
                latch.countDown();
            }).start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main");
    }
}

给CountDownLatch传参5，然后5个线程每次执行进行countDown()，然后在主线程中await()，直至countDown后的结果为0，主线程才输出。
实际应用：比如10个玩家进行王者荣耀时，为了保证游戏的公平性，就需要等待10个玩家都加载好以后才能进入游戏，那么可以用主线程来进行控制等待，十个玩家（十个线程）都进行了countDown()之后，主线程恢复运行，即可以开始游戏。
代码实现：

public class CountDownTest2 {
    public static void main(String[] args) throws InterruptedException {
        //十个玩家，所以是十个计数
        CountDownLatch latch = new CountDownLatch(10);
        System.out.println("玩家准备");
        String[] str = new String[10];
        Random random = new Random();
        for(int i = 0; i <10; i++) {
            //因为匿名内部类只能调用外部被final修饰的常量，所以将i赋值给x
            final int x = i;
            //共创建十个线程
            new Thread(() -> {
                for(int j = 0; j <= 100; j++) {
                    try {
                        //睡眠时间使用随机数，实现游戏加载的不确定性
                        Thread.sleep(random.nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //锁住数组对象
                    synchronized (str) {
                        str[x] = (j + "%");
                        System.out.print("\r" + Arrays.toString(str));   //使用\r，跳到表头
                    }
                }
                //计数减一
                latch.countDown();   
            }).start();
        }

        latch.await();
        System.out.println("\n进入游戏");
    }
}

执行结果：
在这里插入图片描述

CyclicBarrier

CyclicBarrier，用于控制线程的数量，如车满多少人才能发车，如拼夕夕满多少人才能拼团成功
可以在创建CyclicBarrier对象时，传入int类型的参数，表示用于限制的数量，也可以传入两个参数，分别是数量和一个线程，在达到数量时，在线程中进行操作，代码如下：

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(4, ()-> System.out.println("发车啦！"));

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

执行结果：
在这里插入图片描述

Semaphore

这个的作用其实相当于“限流”，即最多同时允许多少个线程进行。例如买景点门票，一共有5个窗口，那么就同时最多允许5个人在同时买票。但是需要注意：Semaphore默认是非公平的。如果想要公平，需要在构造方法传参为true。
Semahore中，一般会使用acquire()，意思为线程想要运行需要先得到许可，当许可为0时，线程就必须等待 ，当线程运行完，需要调用release()，将锁释放，这样，其他线程继续进行acquire()。
进行一个测试，一共有5个线程，但是同时可以进行的只能有2个，那么就会两个线程通知争取，释放后继续两两争取。代码如下：

public class SemaphoreTest {
    static Semaphore semaphore = new Semaphore(2/*, true*/); //有true参数为公平锁
    public static void main(String[] args) {
        for(int i = 0; i <5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName() + "获取锁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

Exchanger

不怎么会用到的一个并发类，用于交换两个线程的同一个类型名称的数据值，当然，也仅仅适用于两个线程
示例：两个线程中都有字符串s，调用其exchange()，然后输出，会发现值已交换，代码如下：

public class ExchangeTest {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        new Thread(() -> {
            String s = "T1";
            try {
                exchanger.exchange(s);
                System.out.println(Thread.currentThread().getName() + " : " + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(() -> {
            String s = "T2";
            try {
                exchanger.exchange(s);
                System.out.println(Thread.currentThread().getName() + " : " + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2").start();

    }
}

执行结果：
在这里插入图片描述

LockSupport

用于支持线程的一个类，但是我们可以直接拿来用~
里面有这样的两个方法，park()：将当前线程阻塞住，unpark()：将阻塞的线程又解封了
试一下~我们在一个线程中每隔0.5秒打印一次数字，当数字值为5时阻塞住，然后经过4秒解封并给出提示，看看代码吧：

public class LockSupportTest {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for(int i = 0; i <10; i++) {
                System.out.println(i);
                if(i == 5) {
                    LockSupport.park();
                }

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("4秒过去了...");
        LockSupport.unpark(t);
    }
}

执行结果：
在这里插入图片描述
是不是很神奇呢，我们可以随意的控制线程的阻塞和恢复，并且不需要加锁就可以实现！那如果一般情况下该如何实现阻塞和恢复呢？一般都是使用wait()和notify()，并且并不能精确的唤醒某一个线程，而LockSupport可以精确的阻塞和唤醒线程

szy2333
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
JUC多线程学习个人笔记
07-08
锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁控制和线程的等待和唤醒机制。 并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作...
JUC的各种同步锁
lovehello的专栏
07-26 230
Atomic** 类 采用的是CAS方式 LongAdder类 采用的是分段锁 package juc.lock; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.LongAdder; public class AtomicVSSynchronized { static long count1 = 0; static AtomicInteger co...
Volatile与各种JUC同步锁
耀的专栏
10-25 124
Volatile保证线程可见性 --MESI --缓存一致性协议 线程可见性在CPU级别是通过缓存一致性协议保证的 Volatile禁止指令重排序（CPU） 指令重排序在CPU级别是无法禁止的，因为是在CPU内部运行的原理。而在jvm中加上volatile关键字是可以实现禁止指令重排序的，volatile给CPU发出指令，CPU中有原语指令 loadfence（读屏障）和storefence（写屏障）的操作 - DCL单例 -Double Check Lock -Mgr06.java...
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
胜天半子祁同伟
09-11 3990
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
JUC同步锁（五）
weixin_30488313的博客
01-04 136
根据锁的添加到Java中的时间，Java中的锁，可以分为“同步锁”和“JUC包中的锁”。 一、同步锁--synchronized关键字 通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。 同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能进行CPU调度，...
JUC并发编程——锁
weixin_39555954的博客
12-30 578
锁
JUC之各种锁
Y_Ace的博客
04-15 566
公平锁和非公平锁 回头看一下之前的一个多线程买票案例 public class LockSaleTicket { public static void main(String[] args) { LockTicket lockTicket = new LockTicket(); new Thread(()->{ for (int i = 0; i < 20; i++) { lockTicket.sal
JUC同步锁 同步工具类 AQS底层
WindNolose的博客
11-23 84
JUC同步锁 1. LongAdder 分段锁，分为片断来上锁 也就是把不同的线程进行分组，最后再进行统计加和 底层每个线程也是CAS操作 2. ReentrantLock lockInterruptibly：表示抢锁的时候，可以被设标志位打断抢锁 Condition：本质就是等待队列，ReentrantLock可以有多个等待队列，用于执行不同的事情 公平锁与不公平锁 ○ 默认是非公平锁，可以传入一个boolean来决定 ○ 公平锁是指才来的线程需要去队列排队，不能直接抢锁，保证线程获取到资源的概
JUC-ReentrantLock锁基础篇
zqj1172102457的博客
06-25 421
ReentrantLock是一种可重入的独占锁(互斥锁)。 独占锁: 一个线程获取()了这把锁，其他的线程则不能获取。 可重入：指的是线程A获取了这把锁，在线程A释放锁之前，线程A本身可以继续来获取这把锁。比如线程A调了了lock()方法获取了这把锁，在线程A调用unlock()方法之前，线程A本身继续调用lock()方法并不会阻塞住。重入锁的设计目的是为了解决死锁的问题。 ReentrantLock常常与Synchronized做对比，它们之间的对比如下:ReentrantLock提供的一些常用的方法有：
Java JUC - 7 Lock 同步锁
个人纪录、总结！
05-17 95
Java JUC - 7 Lock 同步锁Java JUC - 目录7.1 显示锁 Lock7.1.1 简介7.1.2 代码 Java JUC - 目录 Java JUC - 目录 7.1 显示锁 Lock 7.1.1 简介 在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。 ReentrantLock 实现了 Lock
JUC-ReentrantReadWriteLock锁基础篇
zqj1172102457的博客
06-26 243
ReentrantReadWriteLock是一种读写锁,它与ReentrantLock的用法才不多，那么为啥还要有读写锁呢。 在业务开发中我们会遇到读写操作，面对读写的数据同步，我们用ReentrantLock锁就可以实现了，但是在实际的读写业务场景中还是读的操作多，写的操作少，那么ReentrantLock锁的效率就会显的很低下。因为无论是读还是写操作，ReentrantLock都要去获取锁。也就是读写互斥，读读也是互斥的。但是我们知道读读互斥其实是不用的，因为我们使用锁的初衷是为了保证数据的同步。读又
JUC相关知识和底层实现原理分析.jpg
09-02
JUC底层实现原理分析，结构多线程更加贯彻同步知识
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_同步锁 Lock ·8. 尚硅谷_JUC线程高级_生产者消费者案例-虚假唤醒 ·9. 尚硅谷_JUC线程高级_Condition 线程通信 ·10. 尚硅谷_JUC线程高级_线程按序交替 ·11. 尚硅谷_JUC线程高级_...
java并发编程：juc、aqs
08-09
通过继承 AQS，可以实现不同的同步机制，如独占锁、共享锁等。 高效的等待队列： AQS 内部维护了一个等待队列，用于管理等待锁的线程。这个队列的实现基于链表，可以高效地管理大量的等待线程，实现线程的排队和唤醒...
java学习和项目总结
2301_79390585的博客
05-24 589
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 456
1，引入核心关键依赖。
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1325
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
数据访问与Spring Data JPA
最新发布
无远弗届
05-25 456
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
synchronized JUC的区别
06-13
JUC（Java Util Concurrent）是 Java 并发编程的工具包，提供了一系列并发编程工具类，如 ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier 等，可以更灵活地实现线程同步和协作，支持公平锁和非公平锁，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值