Java线程安全问题的解决方案

2024-04-02 19:04:59 183人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录线程安全问题演示解决线程安全问题1.原子类AtomicInteger2.加锁排队执行2.1 同步锁synchronized2.2 可重入锁ReentrantLock3.线程本地变

线程安全问题演示

我们创建一个变量 number 等于 0，之后创建线程 1，执行 100 万次 ++ 操作，同时再创建线程 2 执行 100 万次 -- 操作，等线程 1 和线程 2 都执行完之后，打印 number 变量的值，如果打印的结果为 0，则说明是线程安全的，否则则为非线程安全的，

示例代码如下：

public class ThreadSafeTest {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1_000_000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                number++;
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                number--;
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("number 最终结果：" + number);
    }
}

以上程序的执行结果如下图所示：

从上述执行结果可以看出，number 变量最终的结果并不是 0，和预期的正确结果不相符，这就是多线程中的线程安全问题。

解决线程安全问题

1.原子类AtomicInteger

AtomicInteger 是线程安全的类，使用它可以将 ++ 操作和 -- 操作，变成一个原子性操作，这样就能解决非线程安全的问题了，

如下代码所示：

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerExample {
    // 创建 AtomicInteger
    private static AtomicInteger number = new AtomicInteger(0);
    // 循环次数
    private static final int COUNT = 1_000_000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // ++ 操作
                number.incrementAndGet();
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // -- 操作
                number.decrementAndGet();
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number.get());
    }
}

以上程序的执行结果如下图所示：

2.加锁排队执行

Java 中有两种锁：synchronized 同步锁和 ReentrantLock 可重入锁。

2.1 同步锁synchronized

synchronized 是 JVM 层面实现的自动加锁和自动释放锁的同步锁，它的实现代码如下：

public class SynchronizedExample {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1_000_000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // 加锁排队执行
                synchronized (SynchronizedExample.class) {
                    number++;
                }
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // 加锁排队执行
                synchronized (SynchronizedExample.class) {
                    number--;
                }
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("number 最终结果：" + number);
    }
}

以上程序的执行结果如下图所示：

2.2 可重入锁ReentrantLock

ReentrantLock 可重入锁需要程序员自己加锁和释放锁，它的实现代码如下：

import java.util.concurrent.locks.ReentrantLock;


public class ReentrantLockExample {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1_000_000;
    // 创建 ReentrantLock
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                lock.lock();    // 手动加锁
                number++;       // ++ 操作
                lock.unlock();  // 手动释放锁
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                lock.lock();    // 手动加锁
                number--;       // -- 操作
                lock.unlock();  // 手动释放锁
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("number 最终结果：" + number);
    }
}

以上程序的执行结果如下图所示：

3.线程本地变量ThreadLocal

使用 ThreadLocal 线程本地变量也可以解决线程安全问题，它是给每个线程独自创建了一份属于自己的私有变量，不同的线程操作的是不同的变量，所以也不会存在非线程安全的问题，它的实现代码如下：

public class ThreadSafeExample {
    // 创建 ThreadLocal（设置每个线程中的初始值为 0）
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1_000_000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < COUNT; i++) {
                    // ++ 操作
                    threadLocal.set(threadLocal.get() + 1);
                }
                // 将 ThreadLocal 中的值进行累加
                number += threadLocal.get();
            } finally {
                threadLocal.remove(); // 清除资源，防止内存溢出
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < COUNT; i++) {
                    // -- 操作
                    threadLocal.set(threadLocal.get() - 1);
                }
                // 将 ThreadLocal 中的值进行累加
                number += threadLocal.get();
            } finally {
                threadLocal.remove(); // 清除资源，防止内存溢出
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number);
    }
}

以上程序的执行结果如下图所示：

总结

在 Java 中，解决线程安全问题的手段有 3 种：1.使用线程安全的类，如 AtomicInteger 类；2.使用锁 synchronized 或 ReentrantLock 加锁排队执行；3.使用线程本地变量 ThreadLocal 来处理。

到此这篇关于Java线程安全问题的解决方案的文章就介绍到这了,更多相关Java线程安全内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java线程安全问题的解决方案

本文链接: https://www.lsjlt.com/news/148389.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java线程安全问题的解决方案

目录线程安全问题演示解决线程安全问题1.原子类AtomicInteger2.加锁排队执行2.1 同步锁synchronized2.2 可重入锁ReentrantLock3.线程本地变...

99+

2024-04-02
详解SimpleDateFormat的线程安全问题与解决方案

1. 原因SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用,它用来储存和这个sdf相关的日期信息,例如sdf.parse(dateStr), sdf.format(date) 诸如此类的方法参数传入的日...

99+

2023-05-31

simpledateformat 线程 dat
Java多线程 - 线程安全和线程同步解决线程安全问题

文章目录线程安全问题线程同步方式一: 同步代码块方式二: 同步方法方式三: Lock锁线程安全问题线程安全问题指的是: 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。举例:...

99+

2023-08-20

java 安全 jvm
Java多线程之线程安全问题怎么解决

本篇内容主要讲解“Java多线程之线程安全问题怎么解决”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java多线程之线程安全问题怎么解决”吧!1.线程安全概述1.1什么是线程安全问题首先我们需要...

99+

2023-06-30
java treemap线程安全问题怎么解决

要解决Java TreeMap的线程安全问题，有以下几种方法：1. 使用Collections.synchronizedMap()方...

99+

2023-10-20

java
Java使用线程同步解决线程安全问题详解

第一种方法：同步代码块：作用：把出现线程安全的核心代码上锁原理：每次只能一个线程进入，执行完毕后自行解锁，其他线程才能进来执行锁对象要求：理论上，锁对象只要对于当前同时执行的线...

99+

2024-04-02
Java多线程下解决数据安全问题

目录同步代码块同步方法lock锁同步代码块基本语句 synchronized (任意对象) { 操作共享代码 } 代码示例 public class SellTicket ...

99+

2024-04-02
Java SimpleDateFormat线程不安全问题怎么解决

本篇内容主要讲解“Java SimpleDateFormat线程不安全问题怎么解决”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java SimpleDateFormat线程...

99+

2023-07-05
java的SimpleDateFormat线程不安全的几种解决方案

目录场景SimpleDateFormat线程为什么是线程不安全的呢？验证SimpleDateFormat线程不安全解决方案解决方案1：不要定义为static变量，使用局部变量解决方案...

99+

2024-04-02
Java多线程之线程安全问题详解

目录1. 什么是线程安全和线程不安全？2. 自增运算为什么不是线程安全的？3. 临界区资源和竞态条件总结：面试题：什么是线程安全和线程不安全？自增运算是不是线程安全的？如何保证多线...

99+

2024-04-02
Java多线程编程中的并发安全问题及解决方法

目录线程安全性死锁定义实现一个死锁查看死锁解决死锁其他线程安全问题单例模式线程安全性线程安全是指我们所写的代码在并发情况下使用时，总是能表现出正确的行为；反之，未实现线程安全的代码...

99+

2023-05-16

Java多线程并发安全 Java并发安全问题 Java多线程并发
如何解决Java中SimpleDateFormat线程不安全的问题

这篇文章将为大家详细讲解有关如何解决Java中SimpleDateFormat线程不安全的问题，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。1.什么是线程不安全？线程不安全也叫非线程安全，是指多线程执行中...

99+

2023-06-15
Java项目中的线程安全问题如何解决

这篇文章给大家介绍Java项目中的线程安全问题如何解决，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。解决方案如下：public class Demo_5 { public&nbs...

99+

2023-05-31

java 线程安全 ava
解决Java中SimpleDateFormat线程不安全的五种方案

目录1.什么是线程不安全？线程不安全的代码 2.解决方案 ① 将SimpleDateFormat变为局部变量 ② 使用synchronized加锁 ③ 使用Lock加锁 ④ 使用T...

99+

2024-04-02
Java中线程安全问题

目录一.线程不安全二.那些情况导致了线程不安全？三.Java中解决线程不安全的方案1.volatile“轻量级”解决线程不安全2.synchronized自动加锁四.公平锁与非公平锁...

99+

2024-04-02
java多线程题目的解决方案

本篇文章为大家展示了java多线程题目的解决方案，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。在iteye上看到的一道多线程的题目，参考了一下网友的实现，那Eclipse调试通过，算是对JAVA5的...

99+

2023-06-17
Java多线程之线程安全问题

文章目录一. 线程安全概述1. 什么是线程安全问题2. 一个存在线程安全问题的程序二. 线程不安全的原因和线程加锁1. 案例分析2. 线程加锁2.1 理解加锁2.2 synchroni...

99+

2023-09-21

java 线程安全多线程 synchronized jvm
关于java中线程安全问题详解

目录一、什么时候数据在多线程并发的环境下会存在安全问题？二、怎么解决线程安全问题？三、银行取钱/存钱案例为什么会出现线程安全问题四、总结一、什么时候数据在多线程并发的环境下会存...

99+

2024-04-02
Java单例模式中的线程安全问题怎么解决

今天小编给大家分享一下Java单例模式中的线程安全问题怎么解决的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。一. 使用多线程...

99+

2023-07-02
golang map线程安全问题怎么解决

在Go语言中，Map是并发不安全的，如果多个goroutine同时对同一个Map进行读写操作，可能会导致数据竞争问题。为了解决Ma...

99+

2024-02-29

golang