Synchronized、Reetrantlock

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量934 收藏 5
点赞数 24
分类专栏： JUC 文章标签： java redis jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30166465/article/details/141931600
版权

一、线程安全问题

多线程操作共享变量，由于该共享变量不是立刻可见的，读写不具备原子性，所以存在线程安全问题

二、售票案例

模拟售票案例，库存有10张票，有3个窗口(3个子线程)分别去卖，直到库存为0；

public class MyCount {
    public int ticket = 10;

    public void sell() {
        //调用多个线程去把ticket减到0
        for (int i = 0; i < 3; i++){
            new Thread(()->{
                while (true){
                    if (ticket>0){
                        //模拟售票耗费时间0.1秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        ticket--;
                        System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
                    }else {
                        break;
                    }
                }

            },"线程"+i).start();
        }
    }
    
    public static void main(String[] args) {
        MyCount myCount = new MyCount();
        myCount.sell();
    }
}

出现超卖和重卖的问题

在这里插入图片描述

三、Sychronized

3.1 修饰代码块

将同步代码块用sychronized(){ }标记。操作相同的共享变量的线程竞争的锁对象必须是同一个，放在小括号里。

    public void sell() {
        //调用多个线程去把ticket减到0
        for (int i = 0; i < 3; i++){
            new Thread(()->{
                while (true){
                    // 加synchronized
                    synchronized (MyCount.class){
                        if (ticket>0){
                            //模拟售票耗费时间0.1秒
                            try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            ticket--;
                            System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
                        }else {
                            break;
                        }
                    }
                }

            },"线程"+i).start();
        }
    }

在这里插入图片描述

修改synchronized的锁对象，发现锁失效了。
原因是每个线程里都有各自的obj对象，不是同一个。

在这里插入图片描述

在这里插入图片描述

3.2 修饰方法

注意：这里多个Thread使用的是同一个实现了Runnable接口的类的对象

public class MyCount {
    public void sell() {
        //调用多个线程去把ticket减到0
        Window w = new Window();
        for (int i = 0; i < 3; i++){
            new Thread(w,"线程"+i).start();
        }
    }

    public static void main(String[] args) {
        MyCount myCount = new MyCount();
        myCount.sell();
    }
}

class Window implements Runnable{
    private int ticket = 10;

    @Override
    public void run() {
        while (true){
            this.sell();
        }
    }
    synchronized void sell(){
        if (ticket>0){
            //模拟售票耗费时间0.1秒
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket--;
            System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
        }
    }
}

在这里插入图片描述

3.3 synchronized总结

  • 任意对象都可以作为同步锁。
  • 同步方法的锁：静态方法(类名.class)、非静态方法(this)
  • 同步代码块：自己指定，很多时候也是指定为this或类名.class

四、Reentrantlock

4.2 使用流程

使用流程

  1. 实例化 ReentrantLock
  2. 调用锁定方法lock()
  3. 调用解锁方法unlock()

在这里插入图片描述
如果同步代码块会有异常，要把unlock()写到finally

import java.util.concurrent.locks.ReentrantLock;

public class MyCount {
    public int ticket = 10;
    private final ReentrantLock lock = new ReentrantLock();
    public void sell() {
        //调用多个线程去把ticket减到0
        for (int i = 0; i < 3; i++){
            new Thread(()->{
                while (true){
                    //获取锁
                    lock.lock();
                    //需要保证线程安全的代码
                    try{
                        if (ticket>0){
                            //模拟售票耗费时间0.1秒
                            try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            ticket--;
                            System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
                        }else {
                            break;
                        }
                    }finally {
                        //释放锁
                        lock.unlock();
                    }
                }

            },"线程"+i).start();
        }
    }

    public static void main(String[] args) {
        MyCount myCount = new MyCount();
        myCount.sell();
    }
}

默认是非公平锁，也就是后来的线程也可能抢到锁。
在这里插入图片描述

4.2 公平锁

公平锁：线程会排队，排在前面的先获得锁。如果这个锁是公平锁，那么线程来的时候会检查队列里是否有别的线程在排队，如果有的话就进队列里让别的线程先运行。

private final ReentrantLock lock = new ReentrantLock(true);

在这里插入图片描述

4.3 尝试获取锁tryLock()

  • 不管锁有没有获取到，都会继续向下执行，而不会阻塞。
  • 有返回值，返回是否成功获取到了锁
    public void sell() {
        //调用多个线程去把ticket减到0
        for (int i = 0; i < 3; i++){
            new Thread(()->{
                while (true){
                    //获取锁
                    boolean tried = lock.tryLock();
                    System.out.println(Thread.currentThread().getName()+"尝试获取锁:"+tried);
                    //需要保证线程安全的代码
                    try{
                        if (ticket>0){
                            //模拟售票耗费时间0.1秒
                            try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            ticket--;
                            System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
                        }else {
                            break;
                        }
                    }finally {
                        //释放锁
                        lock.unlock();
                    }
                }

            },"线程"+i).start();
        }
    }

这里抛出异常是因为，没有获取到锁但是却有调用了unlock()

在这里插入图片描述
所以需要在unlock之前判断一下是否获取到了锁

    public void sell() {
        //调用多个线程去把ticket减到0
        for (int i = 0; i < 3; i++){
            new Thread(()->{
                while (true){
                    //获取锁
                    boolean tried = lock.tryLock();
                    //需要保证线程安全的代码
                    try{
                        //如果获取成功
                        if (tried){
                            if (ticket>0){
                                //模拟售票耗费时间0.1秒
                                try {
                                    Thread.sleep(100);
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                                ticket--;
                                System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);
                            }else {
                                break;
                            }
                        }
                    }finally {
                        //释放锁
                        if (tried){
                            lock.unlock();
                        }
                    }
                }

            },"线程"+i).start();
        }
    }

在这里插入图片描述

4.3 lockInterrruptibly()可中断地获取锁

正解：当t1执行时间很长，t2(获取锁时采用lockInterrruptibly()方式)一直在等待获取锁，一直获取不到，这时候t2可以被别的线程中断。
如果t2是lock方式获取锁，那他只能陷入无休止的等待获取锁的过程中，不能直接被中断

这是错误的：线程t1调用lockInterrruptibly()方法获取锁后，别的线程可以立刻打断t1的执行

    public void sell() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                lock.lock();
                System.out.println("t1 start");
                Thread.sleep(Long.MAX_VALUE);
                System.out.println("t1 end");
            } catch (InterruptedException e) {
                System.out.println("t1 被中断");
            } finally {
                lock.unlock();
            }
        });
        t1.start();

        // 阻塞1秒，保证上面的线程先执行，先获取到锁
        Thread.sleep(1000);

        Thread t2 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
                System.out.println("t2 start");
                Thread.sleep(Long.MAX_VALUE);
                System.out.println("t2 end");
            } catch (InterruptedException e) {
                System.out.println("t2 被中断");
            } finally {
                //lock.unlock();
            }
        });
        t2.start();

        Thread.sleep(3000);
        t2.interrupt();
    }

在这里插入图片描述
将lock.lockInterruptibly()改为lock.lock()后

在这里插入图片描述

synchronized.md
02-24
关于synchronized的自学笔记
java synchronized demo
04-19
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它用于实现线程同步，以确保多线程环境下的数据一致性与安全性。本示例"java synchronized demo"旨在探讨`synchronized`关键字的用法及其作用机制。...
Android synchronized 测试案例
07-16
在Android开发中，`synchronized`关键字是Java语言中用于实现线程同步的重要工具，它在多线程环境下确保了共享资源的安全访问。本测试案例深入探讨了`synchronized`的使用方法，包括同步单个对象、同步多个对象以及...
手写synchronized
07-18
(此代码不能运行，因为很多c++中的机制在java中不能实现)此代码仅用于学习synchronized的过程，从看了synchronized的源码后，根据c++中synchronized进行java手写。以MySynchronized类的monitorEnter方法为加锁入口，...
synchronized并发讲解源码.zip
03-16
在Java编程语言中，`synchronized`关键字是一个非常重要的并发控制机制，用于保证多线程环境下的数据一致性。本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 105
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 236
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 261
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 467
在方法、构造函数或块内部定义的变量。
JAVA学习接口案例实例
shangan_3的博客
11-08 205
【代码】JAVA学习接口案例实例。
Spring资源加载模块，原来XML就这，活该被注解踩在脚下 手写Spring第六篇了
mkii_hong的博客
11-11 642
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 673
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 342
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
SpringMVC
hi_zf的博客
11-11 106
处理器映射器: HandlerMapping。处理器适配器: HandlerAdapter。视图解析器: ViewResolver。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1009
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
greendao使用封装
白高林的专栏
11-07 453
greenDAO
MySQL 到 ClickHouse 数据同步优化（三）
Kami‘s home
11-08 827
CloudCanal 再次优化 MySQL 到 ClickHouse 数据链路，大幅提升数据同步性能，帮助业务快速构建实时数据分析环境。
JavaScript 高阶总结
qq_43787947的博客
11-11 439
JavaScript 高级总结
C++接口类， 抽象类和实体类简述
Joshua的专栏
11-09 307
在C++中，接口类通常是指只包含纯虚函数（pure virtual functions）的类。接口类的主要目的是定义一组通用的行为，但不提供任何具体的实现。通过上述示例可以看出，C++通过抽象类和多重继承实现了类似Java中的单一实体继承和多接口继承的效果。在C++中，虽然没有像Java那样明确的“接口”关键字，但可以通过抽象类和纯虚函数来实现接口的概念。实体类是指可以实例化的类，即类中所有的函数都有具体的实现，包括继承自抽象类的纯虚函数。单实体继承（多接口继承）的设计理念和好处。类继承和接口继承的比较。
synchronized和reetrantlock
08-08
synchronized和ReentrantLock都是Java中用于实现线程同步的机制。 synchronized是Java中最基本的同步机制，它可以用于修饰方法和代码块，保证同一时刻只有一个线程能够访问被synchronized修饰的代码。synchronized...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值