并发编程与高并发（一）：线程安全性

帅过驴的袋鼠

已于 2022-02-15 14:04:00 修改

阅读量712

点赞数 1

分类专栏：高并发与多线程文章标签： java

于 2021-09-07 17:40:54 首次发布

本文链接：https://blog.csdn.net/qq_42163058/article/details/120158558

版权

本文介绍了线程安全的概念及其三个特性：原子性、可见性和有序性。详细讨论了Java中Atomic类如何保证原子性，以及synchronized和volatile关键字在确保可见性方面的作用。此外，还提到了并发编程中的锁机制、ABA问题以及LongAdder的使用场景。通过对并发特性的理解，有助于提升Java多线程编程的能力。

摘要由CSDN通过智能技术生成

概览

什么是线程安全

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么这个类就是线程安全的。

线程安全三个特性

原子性：是指一次或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么全部回滚。

可见性：一个线程对主内存的修改可以及时的被其他线程观察到。

有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序。

一、原子性

是指一次或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么全部回滚。

Atomic

先来看一段代码


import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class AtomicIntegerTestNotSafe {

    private static Integer count = 0;

    public static void main(String[] args) throws Exception {

        final Semaphore semaphore = new Semaphore(200);
        final CountDownLatch countDownLatch = new CountDownLatch(5000);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5000; i++) {
            executorService.execute(() -> {
                try {

                    semaphore.acquire();

                    count++;

                    semaphore.release();

                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }
        // 主线程等待
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count = " + count); // count = 4777
    }
}

理论上我们希望最后输出的 count 是5000，但是实际上输出的值不到5000。

这个类就是线程不安全的类，那么如何解决这个问题呢，使用Atomic包下面的类来避免出现这种问题。


import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTestSafe {

    private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws Exception{

        final Semaphore semaphore = new Semaphore(200);
        final CountDownLatch countDownLatch = new CountDownLatch(5000);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5000; i++) {
            executorService.execute(() -> {
                try {

                    semaphore.acquire();

                    count.incrementAndGet();

                    semaphore.release();

                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }
        // 主线程等待
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count = " + count); // count = 5000
    }

}

通过源码来看看 AtomicInteger 是如何保证线程安全的

incrementAndGet()

    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

getAndAddInt(Object var1, long var2, int var4)

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        // 重点在于 compareAndSwapInt 这个方法
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

这个方法采用CAS来保证线程安全࿰