Atomic Integer and Atomic Reference for Multithreading

1 原子整数

J.U.C Concurrent packets provide some atomic types of numbers

• AtomicBoolean

• AtomicInteger

• AtomicInteger

AtomicInteger i = new AtomicInteger(0);

// 获取并自增（i = 0, 结果 i = 1, 返回 0）,类似于 i++
System.out.println(i.getAndIncrement());

// 自增并获取（i = 1, 结果 i = 2, 返回 2）,类似于 ++i
System.out.println(i.incrementAndGet());

// 自减并获取（i = 2, 结果 i = 1, 返回 1）,类似于 --i
System.out.println(i.decrementAndGet());

// 获取并自减（i = 1, 结果 i = 0, 返回 1）,类似于 i--
System.out.println(i.getAndDecrement());

// 获取并加值（i = 0, 结果 i = 5, 返回 0）
System.out.println(i.getAndAdd(5));

// 加值并获取（i = 5, 结果 i = 0, 返回 0）
System.out.println(i.addAndGet(-5));

// 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
System.out.println(i.getAndUpdate(p -> p - 2));

// 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
System.out.println(i.updateAndGet(p -> p + 2));

// 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
// getAndUpdate 如果在 lambda 中引用了外部的局部变量,要保证该局部变量是 final 的
// getAndAccumulate 可以通过 参数1 来引用外部的局部变量,但因为其不在 lambda 中因此不必是 final
System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));

// 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0）
System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));

2 原子引用

The atomic reference types provided are:

• AtomicReference
• AtomicMarkableReference
• AtomicStampedReference

Withdrawal case

public interface DecimalAccount {
    
 // 获取余额
 BigDecimal getBalance();
    
 // 取款
 void withdraw(BigDecimal amount);
    
     /** * 方法内会启动 1000 个线程,每个线程做 -10 元 的操作 * 如果初始余额为 10000 那么正确的结果应当是 0 */
     static void demo(DecimalAccount account) {
    
     List<Thread> ts = new ArrayList<>();
         
     for (int i = 0; i < 1000; i++) {
    
         ts.add(new Thread(() -> {
    
         account.withdraw(BigDecimal.TEN);
         }));
     }
     ts.forEach(Thread::start);
     ts.forEach(t -> {
    
         try {
    
         t.join();
     } catch (InterruptedException e) {
    
         e.printStackTrace();
     }
 });
     System.out.println(account.getBalance());
 }
}

不安全实现

class DecimalAccountUnsafe implements DecimalAccount {
    
     BigDecimal balance;
     public DecimalAccountUnsafe(BigDecimal balance) {
    
     this.balance = balance;
     }
    
     @Override
     public BigDecimal getBalance() {
    
     return balance;
     }
    
     @Override
     public void withdraw(BigDecimal amount) {
    
     BigDecimal balance = this.getBalance();
     this.balance = balance.subtract(amount);
     }
}

安全实现-加锁

class DecimalAccountSafeLock implements DecimalAccount {
    
     private final Object lock = new Object();
     BigDecimal balance;
    
     public DecimalAccountSafeLock(BigDecimal balance) {
    
     this.balance = balance;
     }
    
     @Override
     public BigDecimal getBalance() {
    
     return balance;
     }
    
     @Override
     public void withdraw(BigDecimal amount) {
    
         synchronized (lock) {
    
         BigDecimal balance = this.getBalance();
         this.balance = balance.subtract(amount);
         }
     }
}

安全实现-CAS

class DecimalAccountSafeCas implements DecimalAccount {
    
     AtomicReference<BigDecimal> ref;
    
     public DecimalAccountSafeCas(BigDecimal balance) {
    
         ref = new AtomicReference<>(balance);
     }
    
     @Override
     public BigDecimal getBalance() {
    
     return ref.get();
     }
    
     @Override
     public void withdraw(BigDecimal amount) {
    
         while (true) {
    
             BigDecimal prev = ref.get();
             BigDecimal next = prev.subtract(amount);
             if (ref.compareAndSet(prev, next)) {
    
                 break;
             }
         }
     }
}

测试

public static void main(String[] args) {
    
    DecimalAccount.demo(new DecimalAccountUnsafe(new BigDecimal("10000")));
    DecimalAccount.demo(new DecimalAccountSafeLock(new BigDecimal("10000")));
    DecimalAccount.demo(new DecimalAccountSafeCas(new BigDecimal("10000")));
}
/* 运行结果: 4100 cost: 425 ms 0 cost: 285 ms 0 cost: 274 ms */

3 ABA问题

案例

    static AtomicReference<String> ref = new AtomicReference<>("A");

    public static void main(String[] args) throws InterruptedException {
    
         log.debug("main start...");
         // 获取值 A
         // 这个共享变量被它线程修改过？
         String prev = ref.get();
         other();
         sleep(1);
         // 尝试改为 C
         log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
    }

    private static void other() {
    
         new Thread(() -> {
    
         log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
         }, "t1").start();
         sleep(0.5);

         new Thread(() -> {
    
         log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
         }, "t2").start();
    }

/* 输出结果: 11:29:52.325 c.Test36 [main] - main start... 11:29:52.379 c.Test36 [t1] - change A->B true 11:29:52.879 c.Test36 [t2] - change B->A true 11:29:53.880 c.Test36 [main] - change A->C true */

主线程仅能判断出共享变量的值与最初值 A 是否相同,不能感知到这种从 A 改为 B 又 改回 A 的情况

如果主线程希望, 只要有其它线程 changed 共享变量,那么自己的 cas 就算失败,这时,需要再加一个版本号.

AtomicStampedReference

    static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
    public static void main(String[] args) throws InterruptedException {
    
         log.debug("main start...");
         // 获取值 A
         String prev = ref.getReference();
         // 获取版本号
         int stamp = ref.getStamp();
         log.debug("版本 {}", stamp);
         // 如果中间有其它线程干扰,发生了 ABA 现象
         other();
         sleep(1);
         // 尝试改为 C
         log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
    }

    private static void other() {
    
         new Thread(() -> {
    
         log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", 
         ref.getStamp(), ref.getStamp() + 1));
         log.debug("更新版本为 {}", ref.getStamp());
         }, "t1").start();
         sleep(0.5);

         new Thread(() -> {
    
         log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", 
         ref.getStamp(), ref.getStamp() + 1));
         log.debug("更新版本为 {}", ref.getStamp());
         }, "t2").start();
    }
/* 运行结果: 15:41:34.891 c.Test36 [main] - main start... 15:41:34.894 c.Test36 [main] - 版本 0 15:41:34.956 c.Test36 [t1] - change A->B true 15:41:34.956 c.Test36 [t1] - 更新版本为 1 15:41:35.457 c.Test36 [t2] - change B->A true 15:41:35.457 c.Test36 [t2] - 更新版本为 2 15:41:36.457 c.Test36 [main] - change A->C false */

说明:

AtomicStampedReference 可以给原子引用加上版本号,追踪原子引用整个的变化过程,如： A -> B -> A -> C ,通过AtomicStampedReference,我们可以知道,引用变量中途被更改了几次.

但有时候,Don't care how many times the variable has changed,Only care if it has been changed.使用到AtomicMarkableReference

Take garbage bags, for example,装满了,replace it,并标识

class GarbageBag {
    
     String desc;
    
     public GarbageBag(String desc) {
    
     this.desc = desc;
     }
    
     public void setDesc(String desc) {
    
     this.desc = desc;
     }
    
     @Override
     public String toString() {
    
     return super.toString() + " " + desc;
     }
}

@Slf4j
public class TestABAAtomicMarkableReference {
    
    
 public static void main(String[] args) throws InterruptedException {
    
     GarbageBag bag = new GarbageBag("装满了垃圾");
     // 参数2 mark 可以看作一个标记,表示垃圾袋满了
     AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
     log.debug("主线程 start...");
     GarbageBag prev = ref.getReference();
     log.debug(prev.toString());
     
     new Thread(() -> {
    
     log.debug("打扫卫生的线程 start...");
     bag.setDesc("空垃圾袋");
     while (!ref.compareAndSet(bag, bag, true, false)) {
    }
     log.debug(bag.toString());
     }).start();
     
     Thread.sleep(1000);
     log.debug("主线程想换一只新垃圾袋？");
     boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
     log.debug("换了么？" + success);
     log.debug(ref.getReference().toString());
 }
}
/* 运行结果: 2019-10-13 15:30:09.264 [main] 主线程 start... 2019-10-13 15:30:09.270 [main] [email protected] 装满了垃圾 2019-10-13 15:30:09.293 [Thread-1] 打扫卫生的线程 start... 2019-10-13 15:30:09.294 [Thread-1] [email protected] 空垃圾袋 2019-10-13 15:30:10.294 [main] 主线程想换一只新垃圾袋？ 2019-10-13 15:30:10.294 [main] 换了么？false 2019-10-13 15:30:10.294 [main] [email protected] 空垃圾袋 */