Java 多线程（八）：Atomic 包

待我称王封你为后i 2021-10-01 09:12 247阅读 0赞

> 无锁意味着方法未加锁，直观表现为线程之间存在着交叉执行

> 非原子操作例如 number++; number = number + 1; 这些操作实际上分为好几步执行

## Atomic 包介绍 ##

*  Atomic 包是 JDK5 之后提供的，这个包提供了一系列原子类，这些类**允许在多线程环境下，无锁的进行原子操作（当某个线程在执行 Atomic 方法时不会被其它线程打断，其它线程会一直等到该方法执行完成）**
 *  Atomic 底层是借助 CPU 的 CAS 指令来实现的

## Atomic 的作用 ##

> 为了更好的让大家明白 Atomic 的作用，下面通过两个案例来进行分析

### AtomicInteger 实现多线程安全加法 ###

*  Code 1 不能保证共享变量在多线程中的可见性、原子性
 *  Code 2 只能保证共享变量在多线程中的可见性、不能保证原子性
 *  Code 3 能保证共享变量在多线程中的可见性、原子性

#### Code 1（非线程安全） ####

*  下面代码在多线程中不安全，理想的输出结果为 1000，但多运行几次输出结果可能为 990、980，**这是因为共享变量 number 是非线程安全的，而产生的可见性、原子性问题导致的**

public class Code1 {
        public static void main(String[] args) {
    
            Test test = new Test(0);
    
            for (int j = 0; j < 100; j++)
                new Thread(test).start();
    
            System.out.println(test.number);
        }
    
        public static class Test implements Runnable {
    
            public int number;
    
            public Test(int number) {
                this.number = number;
            }
    
            @Override
            public void run() {
                number = number + 1;
                number = number + 2;
                number = number + 3;
                number = number + 4;
            }
            
        }
    }

#### Code 2 （使用 volatile，仍非线程安全） ####

*  下面使用 volatile 修饰变量 number，**volatile 可以保证共享变量 number 在多线程中的可见性，但不能保证原子性**，因此 number 结果仍可能不正确（不为 1000）

public class Code2 {
        public static void main(String[] args) {
    
            Test test = new Test();
    
            for (int j = 0; j < 100; j++)
                new Thread(test).start();
    
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("number------------"+test.number);
        }
    
        public static class Test implements Runnable {
    
            volatile public int number;
    
            public Test() {
                this.number = 0;
            }
    
            @Override
            public void run() {
                number = number + 1;
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number = number + 2;
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number = number + 3;
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number = number + 4;
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
            }
        }
    }

*  输出结果可能如下

.....
    ThreadId-108 : 974
    ThreadId-108 : 980
    ThreadId-108 : 983
    ThreadId-109 : 984
    ThreadId-107 : 978
    ThreadId-109 : 990
    ThreadId-109 : 993
    ThreadId-108 : 988
    ThreadId-109 : 997
    number------------997

#### Code 3 （使用 AtomicInteger，线程安全） ####

*  **使用 AtomicInteger 可以保证共享变量的可见性、操作原子性**，因此 number 结果总为正确值（1000）

public class Code3 {
        public static void main(String[] args) {
    
            Test test = new Test(0);
    
            for (int j = 0; j < 100; j++)
                new Thread(test).start();
        }
    
        public static class Test implements Runnable {
    
            public AtomicInteger number;
    
            public Test(int number) {
                this.number = new AtomicInteger(number);
            }
    
            @Override
            public void run() {
                number.addAndGet(1);
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number.addAndGet(2);
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number.addAndGet(3);
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
                number.addAndGet(4);
                System.out.println("ThreadId-" + Thread.currentThread().getId() + " : " + number);
            }
        }
    }

*  输出结果可能如下

......
    ThreadId-108 : 977
    ThreadId-108 : 983
    ThreadId-108 : 986
    ThreadId-109 : 987
    ThreadId-108 : 991
    ThreadId-109 : 993
    ThreadId-109 : 996
    ThreadId-109 : 1000

### AtomicBoolean 解决并发多次初始化问题 ###

*  **AtomicBoolean 的 compareAndSet(boolean expect, boolean update) 方法讲解：**
    
     *  比较 AtomicBoolean 和 expect 的值，如果一致，执行方法内的语句（其实就是一个if语句)，并把 AtomicBoolean 的值设成 update
     *  **这两个动作之间不会被打断，任何内部或者外部的语句都不可能在两个动作之间运行，属于原子操作**

#### Code 1（非并发安全） ####

*  下面代码在多线程并发会存在多次初始化问题，**原因可能是共享变量的可见性与线程争夺交叉执行导致的**

public class Code1 {
        public static void main(String[] args) {
            Test test = new Test(true);
            for (int j = 0; j < 100; j++)
                new Thread(test).start();
        }
    
        public static class Test implements Runnable {
    
            public boolean flag;
    
            public Test(boolean flag) {
                this.flag = flag;
            }
    
            public void init() {
                if (flag) {
                    System.out.println("初始化中1");
                    System.out.println("初始化中2");
                    System.out.println("初始化完毕");
                    flag = false;
                }
            }
    
            @Override
            public void run() {
                init();
            }
    
        }
    }

*  输出结果可能如下，这是因为当线程 1 在执行 init() 初始化时线程 2 抢占到了 CPU 资源，并且也执行了 init() 方法，导致多次初始化

初始化中1
    初始化中2
    初始化完毕
    初始化中1
    初始化中2
    初始化完毕

#### Code 2（使用 AtomicBoolean） ####

*  使用 AtomicBoolean 的 compareAndSet 方法保证 compare 与 set 是原子级操作，可以保证 init() 只被调用一次

public class Code2 {
        public static void main(String[] args) {
            Test test = new Test(true);
            for (int j = 0; j < 100; j++)
                new Thread(test).start();
        }
    
        public static class Test implements Runnable {
    
            AtomicBoolean atomicBoolean;
    
            public Test(boolean flag) {
                this.atomicBoolean = new AtomicBoolean(flag);
            }
    
            public void init() {
                if (atomicBoolean.compareAndSet(true, false)) {
                    System.out.println("初始化中1");
                    System.out.println("初始化中2");
                    System.out.println("初始化完毕");
                }
            }
    
            @Override
            public void run() {
                init();
            }
    
        }
    }

*  因此输出结果总是如下

初始化中1
    初始化中2
    初始化完毕