Java多线程工具包java.util.concurrent---Atomic

java.util.concurrent工具包中提供了很多原子类的工具类，这篇文章主要针对

AtomicBoolean、AtomicInteger、AtomicReference做一个说明

AtomicBoolean

AtomicBoolean 类为我们提供了一个可以用原子方式进行读和写的布尔值，它还拥有一些先进的原子性操作，比如 compareAndSet()。AtomicBoolean 类位于 java.util.concurrent.atomic 包，完整类名是为 java.util.concurrent.atomic.AtomicBoolean

示例

package com.yvan.atomicBoolean;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* AtomicBoolean
* @author yvan
*
*/
public class AppMain {
private static AtomicBoolean flag = new AtomicBoolean(false);
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(4);
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
if (flag.compareAndSet(true, false)) {
System.out.println("flag发现改变，开始执行:" + Thread.currentThread().getName());
countDownLatch.countDown();
}
}
}, 1000, 5000, TimeUnit.MILLISECONDS);
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
if (flag.compareAndSet(false, true)) {
System.out.println("flag发现改变，开始执行:" + Thread.currentThread().getName());
countDownLatch.countDown();
}
}
}, 5000, 5000, TimeUnit.MILLISECONDS);
countDownLatch.await();
scheduledExecutorService.shutdown();
}
}

AtomicInteger

AtomicInteger 类为我们提供了一个可以进行原子性读和写操作的 int 变量，它还包含一系列先进的原子性操作，比如 compareAndSet()。AtomicInteger 类位于 java.util.concurrent.atomic 包，因此其完整类名为 java.util.concurrent.atomic.AtomicInteger。

创建一个 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 的值

compareAndSet 比较更新

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 的值减一，但它返回的是减一之前的值。

示例

package com.yvan.atomicInteger;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
* 模拟连接池
*
* @author yvan
*
*/
public class AppMain {
// 连接池最大连接数
public static final int MAXCONNECT = 10;
// 并发量
public static final int CONCURRENT = 15;

public static void main(String[] args) {
AtomicInteger connectNum = new AtomicInteger(0);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < CONCURRENT; i++) {
executorService.execute(new Connect(connectNum));
}
executorService.shutdown();
}
}

class Connect implements Runnable {
private AtomicInteger connectNum;

public Connect(AtomicInteger connectNum) {
super();
this.connectNum = connectNum;
}

@Override
public void run() {
if (connectNum.incrementAndGet() <= AppMain.MAXCONNECT) {
System.out.println(Thread.currentThread().getName() + "连接进来了");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println("已超过最大连接数!");
}

}

}

某一次结果

pool-1-thread-2连接进来了

pool-1-thread-6连接进来了

pool-1-thread-10连接进来了

pool-1-thread-9连接进来了

pool-1-thread-7连接进来了

pool-1-thread-5连接进来了

pool-1-thread-1连接进来了

pool-1-thread-4连接进来了

已超过最大连接数!

pool-1-thread-3连接进来了

已超过最大连接数!

已超过最大连接数!

已超过最大连接数!

已超过最大连接数!

pool-1-thread-11连接进来了

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 atomicStringReference =

new AtomicReference();

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

String initialReference = “the initially referenced string”;

AtomicReference atomicStringReference = new

AtomicReference(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 atomicReference =

new AtomicReference(“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。