java演示线程安全问题

最新推荐文章于 2025-03-19 11:04:31 发布

Distance失落心

最新推荐文章于 2025-03-19 11:04:31 发布

阅读量885

点赞数 28

分类专栏： java 文章标签： java 安全后端 ide 开发语言

本文链接：https://blog.csdn.net/qq_50665369/article/details/145635422

版权

java 专栏收录该内容

34 篇文章

订阅专栏

线程安全

我的理解：多个线程对共享变量的操作若不加以控制，共享变量的值可能不符合我们的预期。典型场景即卖票：多台售票机并行卖一定数量的票，体现在java代码中就是多个线程并行操作一个代表票数的变量值。

演示

代码示例

package com.lovehena.datastructure;

import lombok.extern.slf4j.Slf4j;

/*
 *   演示线程安全问题
 *       以卖票为例
 *       用2个线程模拟2个售票机售票的过程，售票时，如果剩余票数>0则可以卖票 否则不可以
 * */
@Slf4j
public class ThreadUnsafe {

    private static int totalTicket = 100;

    public static void main(String[] args) {
        /*
            以下代码可能存在线程安全问题，如以下输出
                15:39:44.657 [售票机2] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机2已售出一张票，票号为：100
                15:39:44.656 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：100
                15:39:44.659 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：98
                15:39:44.659 [售票机2] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机2已售出一张票，票号为：99
                15:39:44.659 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：97
                ......
            可以看到 售票机2和售票机1都卖出了票号为100的这张票（重票）
         */
        new Thread(() -> {
            while (totalTicket > 0) {
                log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                totalTicket--;
            }
        }, "售票机1").start();

        new Thread(() -> {
            while (totalTicket > 0) {
                log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                totalTicket--;
            }
        }, "售票机2").start();
    }
}

测试用例输出

可以看到以上输出的结果中，体现了超卖和重票。
如果没有出现，可以用idea debug功能手动模拟。

出现线程安全问题的原因

todo

解决线程安全问题

思路

常见的就是加锁。
如果是单体项目，synchronized代码块、lock锁（一般指的是java.util.concurrent.locks.Lock 这个接口的实现类，如java.util.concurrent.locks.ReentrantLock等）；
如果是分布式项目，加分布式锁即可。一般用redis实现分布式锁，也可以用redisson这个框架（库）提供的api实现分布式锁。
我上面的代码不涉及集群部署的话，就用本地锁解决。

synchronized关键字解决

代码

package com.lovehena.datastructure;

import lombok.extern.slf4j.Slf4j;

/*
 *   演示线程安全问题
 *       以卖票为例
 *       用2个线程模拟2个售票机售票的过程，售票时，如果剩余票数>0则可以卖票 否则不可以
 * */
@Slf4j
public class ThreadUnsafe {

    private static int totalTicket = 100;

    public static void main(String[] args) {
        /*
            以下代码可能存在线程安全问题，如以下输出
                15:39:44.657 [售票机2] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机2已售出一张票，票号为：100
                15:39:44.656 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：100
                15:39:44.659 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：98
                15:39:44.659 [售票机2] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机2已售出一张票，票号为：99
                15:39:44.659 [售票机1] INFO com.lovehena.datastructure.ThreadUnsafe - 售票机1已售出一张票，票号为：97
                ......
            可以看到 售票机2和售票机1都卖出了票号为100的这张票（重票）
         */
        new Thread(() -> {
            // 把可能出现线程安全问题的代码（多个线程操作共享变量的代码 用synchronized关键字包起来即可 用法就是下面这样）
            // 语法：synchronized(一个对象) 对象指的是extends Object的实例
            
            // 保证锁对象是同一个。ThreadUnsafe.class返回的是一个字节码对象 在jvm中只有一个 对每个线程来说肯定是唯一的
            // 实际上用其他的也可以 如某个数字（Integer对象） 某个字符串常量等 只是一般都用ThreadUnsafe.class 或许是为了显得高级些？
            synchronized (ThreadUnsafe.class) {
                while (totalTicket > 0) {
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                }
            }
        }, "售票机1").start();

        new Thread(() -> {
            synchronized (ThreadUnsafe.class) {
                while (totalTicket > 0) {
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                }
            }

        }, "售票机2").start();
    }
}

输出

用ReentrantLock解决

代码

public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock(); // 构造ReentrantLock实例

        new Thread(() -> {

            while (totalTicket > 0) {
                lock.lock(); // 这行代码以下的代码只有获取锁成功后才会执行 获取锁失败会阻塞等待
                try {
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                    try {
                        Thread.sleep(100); // 模拟一个业务中的其他操作
                    } catch (InterruptedException e) {
                        log.error("被打断了...", e);
                    }
                } finally {
                    // 什么时候释放锁？操作完共享变量后
                    lock.unlock(); // 和synchronized不同 需要开发者手动释放代码
                }

            }

        }, "售票机1").start();

        new Thread(() -> {

            while (totalTicket > 0) {
                try {
                    lock.lock();
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        log.error("被打断了...", e);
                    }
                } finally {
                    lock.unlock();
                }

            }

        }, "售票机2").start();
    }

输出

扩展

1.封装ReentrantLock解决线程安全问题的代码。

2.以下代码有什么问题？

public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        new Thread(() -> {
            lock.lock();
            try {
                while (totalTicket > 0) {
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                    try {
                        Thread.sleep(100); // 模拟一个业务中的其他操作
                    } catch (InterruptedException e) {
                        log.error("被打断了...", e);
                    }
                }

            } finally {
                lock.unlock();
            }
        }, "售票机1").start();

        new Thread(() -> {
            lock.lock();
            try {
                while (totalTicket > 0) {
                    log.info("{}已售出一张票，票号为：{}", Thread.currentThread().getName(), totalTicket);
                    totalTicket--;
                    try {
                        Thread.sleep(100); // 模拟一个业务中的其他操作
                    } catch (InterruptedException e) {
                        log.error("被打断了...", e);
                    }
                }
            } finally {
                lock.unlock();
            }
        }, "售票机2").start();
    }