Synchronized、Reetrantlock

康提扭狗兔2024-09-12 19:24

一、线程安全问题

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

二、售票案例

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

java 复制代码 
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(){ }标记。操作相同的共享变量的线程竞争的锁对象必须是同一个，放在小括号里。

java 复制代码 
    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接口的类的对象

java 复制代码 
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

java 复制代码 
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 公平锁

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

java 复制代码 
private final ReentrantLock lock = new ReentrantLock(true);

4.3 尝试获取锁tryLock()

  • 不管锁有没有获取到，都会继续向下执行，而不会阻塞。
  • 有返回值，返回是否成功获取到了锁
java 复制代码 
    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之前判断一下是否获取到了锁

java 复制代码 
    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的执行

java 复制代码 
    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()后

相关推荐
码农研究僧3 分钟前
Java或者前端 实现中文排序（调API的Demo）
java·前端·localecompare·中文排序·collator
Chase-Hart4 分钟前
【每日一题】LeetCode 7.整数反转（数学）
java·数据结构·算法·leetcode·eclipse
四角小裤儿儿10 分钟前
Java数据结构（十一）——归并排序、计数排序
java·数据结构·排序算法
guangzhi063310 分钟前
JVM垃圾回收器
jvm
guangzhi063318 分钟前
JVM本地方法栈
java·jvm·面试
健康平安的活着19 分钟前
JVM 调优篇7 调优案例4- 线程溢出
jvm
懵懵懂懂程序员20 分钟前
JVM堆外泄露分析&解决
jvm
akhfuiigabv23 分钟前
使用LangChain创建简单的语言模型应用程序【快速入门指南】
java·python·语言模型·langchain
忘却的纪念29 分钟前
基于SpringBoot的考研资讯平台设计与实现
java·spring boot·spring
.生产的驴31 分钟前
SpringBoot 消息队列RabbitMQ死信交换机
java·spring boot·后端·rabbitmq·java-rabbitmq
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04CCF-CSP认证考试 202406-3 文本分词 100分题解05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文102024 高教社杯 数学建模国赛 （A题）深度剖析|“板凳龙” 闹元宵|数学建模完整代码+建模过程全解全析