使用AtomicReference 保证多线程对象赋值原子性

AtomicReference 是java.util.concurrent.atomic包下面的类。我们看atomic里有许多对象，里面有操作integer、Long等等数据的原子性类，而我们今天使用的AtomicReference是操作引用的原子性类对象。

我们先看下AtomicReference的构造方法源代码

private volatile V value;


public AtomicReference(V initialValue) {
    value = initialValue;
}

会发现里面我们保存的值value是一个volatile 字段，可以保证所有线程可以拿到最新的值。

我们继续来看重要的方法 compareAndSet

   public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

compareAndSet方法主要功能是将内存里面的值替换为update，而expect会去与内存值进行比较如果不一样就不会更新并返回false。这个就是一个乐观锁，如果引用改变了那么就不更新，通过组织方式可以保证线程安全。(unsafe.compareAndSwapObject是一个native方法有兴趣可以去自己了解)

那我们就来开始实验

@AllArgsConstructor
@Data
public class DebitCard{
    String account;

    Integer amount;
}

  private static AtomicReference<DebitCard> debitCardRef
            = new AtomicReference<>(new DebitCard("zhangsan", 0));
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread("T-" + i) {
                @SneakyThrows
                @Override
                public void run() {
              
                    DebitCard debitCard = debitCardRef.get();
                    // 全部并发 十个线程获取到了 debitCard引用都是同一个
                    cyclicBarrier.await();
                    DebitCard newDebitCard = new DebitCard(debitCard.getAccount(),debitCard.getAmount() + 10);
                    if(debitCardRef.compareAndSet(debitCard,newDebitCard)){
                        System.out.println(newDebitCard);
                    }else{
                        System.out.println("更新失败");
                    }

                    try {
                        TimeUnit.MILLISECONDS.sleep(current().nextInt(20));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }

更新失败
更新失败
更新失败
更新失败
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=10)
更新失败
更新失败
更新失败
更新失败
更新失败

可以看到只有一个能更新成功

我猜你也想到了可以加一个do..while在循环里面进行更新操作就可以保证原子性了，实际上它也是这样实现的,这个也是CAS，我们可以看方法updateAndGet

 public final V updateAndGet(UnaryOperator<V> updateFunction) {
        V prev, next;
        do {
            prev = get();
            next = updateFunction.apply(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

源码里面更新就是这样去做的，那我们改下测试代码

public void run() {
    DebitCard newDebitCard =debitCardRef.updateAndGet((e) -> {
        return new DebitCard(e.getAccount(), e.getAmount() + 10);
    });
    System.out.println(newDebitCard);
    try {
        TimeUnit.MILLISECONDS.sleep(current().nextInt(20));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

AtomicReferenceExample2.DebitCard(account=zhangsan, amount=80)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=100)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=40)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=30)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=10)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=90)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=20)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=60)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=50)
AtomicReferenceExample2.DebitCard(account=zhangsan, amount=70)

ok这样就保证了对象修改的原子性，比synchronized方式要快上不少。