Java高并发编程：原子类

墨蓝 2022-07-14 22:37 287阅读 0赞

## **1. 并发编程概念** ##

### **原子性** ###

一个操作不能被再拆分了；即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。一个很经典的例子就是银行账户转账问题。  
增量操作符++，不是原子的操作，它是先读取旧值，然后写回新值，包含2个操作

### **可见性** ###

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

### **有序性** ###

即程序执行的顺序按照代码的先后顺序执行。但是指令重排序会影响到线程并发执行的正确性

### **总结** ###

要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

### **并发，并行，串行** ###

并行是逻辑上同时发生，指在某一个时间内同时运行多个程序。  
并发是物理上同时发生，指在某一个时间点同时运行多个程序。

## **2. 原子类** ##

java.util.concurrent.atomic包：原子类的小工具包，支持在单个变量上解除锁的线程安全编程

### 2.1 如果同一个变量要被多个线程访问，则可以使用该包中的类 ###

*  AtomicBoolean
 *  AtomicInteger
 *  AtomicLong
 *  AtomicReference

### 2.2 AtomicIntegerArray：操作数组里面的某个整数 ###

### 2.3 同样该包中提供了可以用于反射操作的类 ###

*  AtomicReferenceFieldUpdater
 *  AtomicIntegerFieldUpdater
 *  AtomicLongFieldUpdater

它们可以提供对关联字段类型的访问。

## **3. 原子性布尔 AtomicBoolean** ##

AtomicBoolean 类为我们提供了一个可以用原子方式进行读和写的布尔值，它还拥有一些先进的原子性操作，比如 compareAndSet()。AtomicBoolean 类位于 java.util.concurrent.atomic 包，完整类名是为 java.util.concurrent.atomic.AtomicBoolean。本小节描述的 AtomicBoolean 是 Java 8 版本里的，而不是它第一次被引入的 Java 5 版本。

AtomicBoolean 背后的设计理念在我的[《Java 并发指南》][Java]主题的[《比较和交换》][Link 1]小节有解释。

### **创建一个 AtomicBoolean** ###

你可以这样创建一个 AtomicBoolean：

AtomicBoolean atomicBoolean = new AtomicBoolean();

以上示例新建了一个默认值为 false 的 AtomicBoolean。

如果你想要为 AtomicBoolean 实例设置一个显式的初始值，那么你可以将初始值传给 AtomicBoolean 的构造子：

AtomicBoolean atomicBoolean = new AtomicBoolean(true);

### **获取 AtomicBoolean 的值** ###

你可以通过使用 get() 方法来获取一个 AtomicBoolean 的值。示例如下：

AtomicBoolean atomicBoolean = new AtomicBoolean(true);  
    
    boolean value = atomicBoolean.get();

以上代码执行后 value 变量的值将为 true。

### **设置 AtomicBoolean 的值** ###

你可以通过使用 set() 方法来设置一个 AtomicBoolean 的值。示例如下：

AtomicBoolean atomicBoolean = new AtomicBoolean(true);  
    
    atomicBoolean.set(false);

以上代码执行后 AtomicBoolean 的值为 false。

### **交换 AtomicBoolean 的值** ###

你可以通过 getAndSet() 方法来交换一个 AtomicBoolean 实例的值。getAndSet() 方法将返回 AtomicBoolean 当前的值，并将为 AtomicBoolean 设置一个新值。示例如下：

AtomicBoolean atomicBoolean = new AtomicBoolean(true);  
    boolean oldValue = atomicBoolean.getAndSet(false);

以上代码执行后 oldValue 变量的值为 true，atomicBoolean 实例将持有 false 值。代码成功将 AtomicBoolean 当前值 ture 交换为 false。

### **比较并设置 AtomicBoolean 的值** ###

compareAndSet() 方法允许你对 AtomicBoolean 的当前值与一个期望值进行比较，如果当前值等于期望值的话，将会对 AtomicBoolean 设定一个新值。compareAndSet() 方法是原子性的，因此在同一时间之内有单个线程执行它。因此 compareAndSet() 方法可被用于一些类似于锁的同步的简单实现。

以下是一个 compareAndSet() 示例：

AtomicBoolean atomicBoolean = new AtomicBoolean(true);  
    
    boolean expectedValue = true;  
    boolean newValue      = false;  
    
    boolean wasNewValueSet = atomicBoolean.compareAndSet(expectedValue, newValue);

本示例对 AtomicBoolean 的当前值与 true 值进行比较，如果相等，将 AtomicBoolean 的值更新为 false。

## **4. 原子性整型 AtomicInteger** ##

AtomicInteger 类为我们提供了一个可以进行原子性读和写操作的 int 变量，它还包含一系列先进的原子性操作，比如 compareAndSet()。AtomicInteger 类位于 java.util.concurrent.atomic 包，因此其完整类名为 java.util.concurrent.atomic.AtomicInteger。本小节描述的 AtomicInteger 是 Java 8 版本里的，而不是它第一次被引入的 Java 5 版本。

AtomicInteger 背后的设计理念在我的[《Java 并发指南》][Java]主题的[《比较和交换》][Link 1]小节有解释。

### **创建一个 AtomicInteger** ###

创建一个 AtomicInteger 示例如下：

AtomicInteger atomicInteger = new AtomicInteger();

本示例将创建一个初始值为 0 的 AtomicInteger。  
如果你想要创建一个给定初始值的 AtomicInteger，你可以这样：

AtomicInteger atomicInteger = new AtomicInteger(123);

本示例将 123 作为参数传给 AtomicInteger 的构造子，它将设置 AtomicInteger 实例的初始值为 123。

### **获取 AtomicInteger 的值** ###

你可以使用 get() 方法获取 AtomicInteger 实例的值。示例如下：

AtomicInteger atomicInteger = new AtomicInteger(123);  
    int theValue = atomicInteger.get();

### **设置 AtomicInteger 的值** ###

你可以通过 set() 方法对 AtomicInteger 的值进行重新设置。以下是 AtomicInteger.set() 示例：

AtomicInteger atomicInteger = new AtomicInteger(123);  
    atomicInteger.set(234);

以上示例创建了一个初始值为 123 的 AtomicInteger，而在第二行将其值更新为 234。

### **比较并设置 AtomicInteger 的值** ###

AtomicInteger 类也通过了一个原子性的 compareAndSet() 方法。这一方法将 AtomicInteger 实例的当前值与期望值进行比较，如果二者相等，为 AtomicInteger 实例设置一个新值。AtomicInteger.compareAndSet() 代码示例：

AtomicInteger atomicInteger = new AtomicInteger(123);  
    
    int expectedValue = 123;  
    int newValue      = 234;  
    atomicInteger.compareAndSet(expectedValue, newValue);

本示例首先新建一个初始值为 123 的 AtomicInteger 实例。然后将 AtomicInteger 与期望值 123 进行比较，如果相等，将 AtomicInteger 的值更新为 234。

### **增加 AtomicInteger 值** ###

AtomicInteger 类包含有一些方法，通过它们你可以增加 AtomicInteger 的值，并获取其值。这些方法如下：

*  addAndGet()
 *  getAndAdd()
 *  getAndIncrement()
 *  incrementAndGet()

第一个 addAndGet() 方法给 AtomicInteger 增加了一个值，然后返回增加后的值。getAndAdd() 方法为 AtomicInteger 增加了一个值，但返回的是增加以前的 AtomicInteger 的值。具体使用哪一个取决于你的应用场景。以下是这两种方法的示例：

AtomicInteger atomicInteger = new AtomicInteger();  
    System.out.println(atomicInteger.getAndAdd(10));  
    System.out.println(atomicInteger.addAndGet(10));

本示例将打印出 0 和 20。例子中，第二行拿到的是加 10 之前的 AtomicInteger 的值。加 10 之前的值是 0。第三行将 AtomicInteger 的值再加 10，并返回加操作之后的值。该值现在是为 20。

你当然也可以使用这俩方法为 AtomicInteger 添加负值。结果实际是一个减法操作。

getAndIncrement() 和 incrementAndGet() 方法类似于 getAndAdd() 和 addAndGet()，但每次只将 AtomicInteger 的值加 1。

### **减小 AtomicInteger 的值** ###

AtomicInteger 类还提供了一些减小 AtomicInteger 的值的原子性方法。这些方法是：

*  decrementAndGet()
 *  getAndDecrement()

decrementAndGet() 将 AtomicInteger 的值减一，并返回减一后的值。getAndDecrement() 也将 AtomicInteger 的值减一，但它返回的是减一之前的值。

## **5. 原子性长整型 AtomicLong** ##

AtomicLong 类为我们提供了一个可以进行原子性读和写操作的 long 变量，它还包含一系列先进的原子性操作，比如 compareAndSet()AtomicLong 类位于 java.util.concurrent.atomic 包，因此其完整类名为 java.util.concurrent.atomic.AtomicLong。本小节描述的 AtomicLong 是 Java 8 版本里的，而不是它第一次被引入的 Java 5 版本。

AtomicLong 背后的设计理念在我的[《Java 并发指南》][Java]主题的[《比较和交换》][Link 1]小节有解释。

创建一个 AtomicLong  
创建一个 AtomicLong 如下：

AtomicLong atomicLong = new AtomicLong();

将创建一个初始值为 0 的 AtomicLong。  
如果你想创建一个指定初始值的 AtomicLong，可以：

AtomicLong atomicLong = new AtomicLong(123);

本示例将 123 作为参数传递给 AtomicLong 的构造子，后者将 AtomicLong 实例的初始值设置为 123。  
获取 AtomicLong 的值  
你可以通过 get() 方法获取 AtomicLong 的值。AtomicLong.get() 示例：

AtomicLong atomicLong = new AtomicLong(123);  
    
    long theValue = atomicLong.get();

设置 AtomicLong 的值  
你可以通过 set() 方法设置 AtomicLong 实例的值。一个 AtomicLong.set() 的示例：

AtomicLong atomicLong = new AtomicLong(123);  
    
    atomicLong.set(234);

本示例新建了一个初始值为 123 的 AtomicLong，第二行将其值设置为 234。

### **比较并设置 AtomicLong 的值** ###

AtomicLong 类也有一个原子性的 compareAndSet() 方法。这一方法将 AtomicLong 实例的当前值与一个期望值进行比较，如果两种相等，为 AtomicLong 实例设置一个新值。AtomicLong.compareAndSet() 使用示例：

AtomicLong atomicLong = new AtomicLong(123);  
    
    long expectedValue = 123;  
    long newValue      = 234;  
    atomicLong.compareAndSet(expectedValue, newValue);

本示例新建了一个初始值为 123 的 AtomicLong。然后将 AtomicLong 的当前值与期望值 123 进行比较，如果相等的话，AtomicLong 的新值将变为 234。

### **增加 AtomicLong 值** ###

AtomicLong 具备一些能够增加 AtomicLong 的值并返回自身值的方法。这些方法如下：

*  addAndGet()
 *  getAndAdd()
 *  getAndIncrement()
 *  incrementAndGet()

第一个方法 addAndGet() 将 AtomicLong 的值加一个数字，并返回增加后的值。第二个方法 getAndAdd() 也将 AtomicLong 的值加一个数字，但返回的是增加前的 AtomicLong 的值。具体使用哪一个取决于你自己的场景。示例如下：

AtomicLong atomicLong = new AtomicLong();  
    System.out.println(atomicLong.getAndAdd(10));  
    System.out.println(atomicLong.addAndGet(10));

本示例将打印出 0 和 20。例子中，第二行拿到的是加 10 之前的 AtomicLong 的值。加 10 之前的值是 0。第三行将 AtomicLong 的值再加 10，并返回加操作之后的值。该值现在是为 20。

你当然也可以使用这俩方法为 AtomicLong 添加负值。结果实际是一个减法操作。

getAndIncrement() 和 incrementAndGet() 方法类似于 getAndAdd() 和 addAndGet()，但每次只将 AtomicLong 的值加 1。

### **减小 AtomicLong 的值** ###

AtomicLong 类还提供了一些减小 AtomicLong 的值的原子性方法。这些方法是：

*  decrementAndGet()
 *  getAndDecrement()

decrementAndGet() 将 AtomicLong 的值减一，并返回减一后的值。getAndDecrement() 也将 AtomicLong 的值减一，但它返回的是减一之前的值。

## **6. 原子性引用型 AtomicReference** ##

AtomicReference 提供了一个可以被原子性读和写的对象引用变量。原子性的意思是多个想要改变同一个 AtomicReference 的线程不会导致 AtomicReference 处于不一致的状态。AtomicReference 还有一个 compareAndSet() 方法，通过它你可以将当前引用于一个期望值(引用)进行比较，如果相等，在该 AtomicReference 对象内部设置一个新的引用。

### **创建一个 AtomicReference** ###

创建 AtomicReference 如下：

AtomicReference atomicReference = new AtomicReference();

如果你需要使用一个指定引用创建 AtomicReference，可以：

String initialReference = "the initially referenced string";  
    AtomicReference atomicReference = new AtomicReference(initialReference);

### **创建泛型 AtomicReference** ###

你可以使用 Java 泛型来创建一个泛型 AtomicReference。示例：

AtomicReference<String> atomicStringReference =  
        new AtomicReference<String>();

你也可以为泛型 AtomicReference 设置一个初始值。示例：

String initialReference = "the initially referenced string";  
    AtomicReference<String> atomicStringReference =  new AtomicReference<String>(initialReference);

### **获取 AtomicReference 引用** ###

你可以通过 AtomicReference 的 get() 方法来获取保存在 AtomicReference 里的引用。如果你的 AtomicReference 是非泛型的，get() 方法将返回一个 Object 类型的引用。如果是泛型化的，get() 将返回你创建 AtomicReference 时声明的那个类型。

先来看一个非泛型的 AtomicReference get() 示例：

AtomicReference atomicReference = new AtomicReference("first value referenced");  
    String reference = (String) atomicReference.get();

注意如何对 get() 方法返回的引用强制转换为 String。  
泛型化的 AtomicReference 示例：

AtomicReference<String> atomicReference =   new AtomicReference<String>("first value referenced");
    String reference = atomicReference.get();

编译器知道了引用的类型，所以我们无需再对 get() 返回的引用进行强制转换了。

### **设置 AtomicReference 引用** ###

你可以使用 get() 方法对 AtomicReference 里边保存的引用进行设置。如果你定义的是一个非泛型 AtomicReference，set() 将会以一个 Object 引用作为参数。如果是泛型化的 AtomicReference，set() 方法将只接受你定义给的类型。

AtomicReference set() 示例：

AtomicReference atomicReference = new AtomicReference();  
    atomicReference.set("New object referenced");

这个看起来非泛型和泛型化的没啥区别。真正的区别在于编译器将对你能够设置给一个泛型化的 AtomicReference 参数类型进行限制。

### **比较并设置 AtomicReference 引用** ###

AtomicReference 类具备了一个很有用的方法：compareAndSet()。compareAndSet() 可以将保存在 AtomicReference 里的引用于一个期望引用进行比较，如果两个引用是一样的(并非 equals() 的相等，而是 == 的一样)，将会给AtomicReference 实例设置一个新的引用。

如果 compareAndSet() 为 AtomicReference 设置了一个新的引用，compareAndSet() 将返回 true。否则compareAndSet() 返回 false。

AtomicReference compareAndSet() 示例：

String initialReference = "initial value referenced";  
    
    AtomicReference<String> atomicStringReference =  
        new AtomicReference<String>(initialReference);  
    
    String newReference = "new value referenced";  
    boolean exchanged = atomicStringReference.compareAndSet(initialReference, newReference);  
    System.out.println("exchanged: " + exchanged);  
    
    exchanged = atomicStringReference.compareAndSet(initialReference, newReference);  
    System.out.println("exchanged: " + exchanged);

本示例创建了一个带有一个初始引用的泛型化的 AtomicReference。之后两次调用 comparesAndSet()来对存储值和期望值进行对比，如果二者一致，为 AtomicReference 设置一个新的引用。第一次比较，存储的引用(initialReference)和期望的引用(initialReference)一致，所以一个新的引用(newReference)被设置给 AtomicReference，compareAndSet() 方法返回 true。第二次比较时，存储的引用(newReference)和期望的引用(initialReference)不一致，因此新的引用没有被设置给 AtomicReference，compareAndSet() 方法返回 false。

[Java]: http://tutorials.jenkov.com/java-concurrency/index.html
[Link 1]: http://tutorials.jenkov.com/java-concurrency/compare-and-swap.html