interface Account {
  Integer getBalance();
  void withdraw(Integer amount);
  /**
   * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作     * 如果初始余额为 10000 那么正确的结果应当是 0
   */
  static void demo(Account account) {
    List<Thread> ts = new ArrayList<>();
    long start = System.nanoTime();
    for (int i = 0; i < 1000; i++) {
      ts.add(new Thread(() -> {
        account.withdraw(10);
      }));
    }
    ts.forEach(Thread::start);
    ts.forEach(t -> {
      try {
        t.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    });
    long end = System.nanoTime();
    System.out.println(account.getBalance() + " cost: " + (end - start) / 1000_000 + " ms");
  }
}
//线程不安全的做法
class AccountUnsafe implements Account {
  private Integer balance;
  public AccountUnsafe(Integer balance) {
    this.balance = balance;
  }
  @Override
  public Integer getBalance() {
    return this.balance;
  }
  @Override
  public synchronized void withdraw(Integer amount) {
    balance -= amount;
  }
  public static void main(String[] args) {
    Account.demo(new AccountUnsafe(10000));
  }
}

200, cost:178ms

public class AccountCas implements Account{
    //使用原子整数
    private AtomicInteger balance;
    public AccountCas(int balance) {
        this.balance = new AtomicInteger(balance);
    }
    @Override
    public Integer getBalance() {
        //得到原子整数的值
        return balance.get();
    }
    @Override
    public void withdraw(Integer amount) {
        while(true) {
            //获得修改前的值
            int prev = balance.get();
            //获得修改后的值
            int next = prev-amount;
            //比较并设值
            if(balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
    public static void main(String[] args) {
        Account.demo(new AccountCas(10000));
    }
}

0，cost:94ms

public void withdraw(Integer amount) {
    //需要不断尝试，直到成功为止
       while(true) {
           //比如拿到了旧值1000
           int prev = balance.get();
           //在这个基础上 1000-10 = 990
           int next = prev-amount;
           /*
           compareAndSet正是做这个检查，在set前，先比较prev与当前值
           不一致了，next作废，返回false表示失败
           比如，别的线程已经做了减法，当前值为990
           那么本线程的这次990就作废了，进入while下次循环重试
           一致，以next设置为新值，返回true表示成功
           */
           if(balance.compareAndSet(prev, next)) {
               break;
           }
       }
}

static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) {
   new Thread(()->{
       String pre = ref.get();   // A
       System.out.println("change");
       try {
           other();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("change A->C "+ref.compareAndSet(pre, "C"));
   }).start();
}
static void other() throws InterruptedException {
    new Thread(()->{
        System.out.println("change A->B " + ref.compareAndSet("A", "B"));
    }).start();
    Thread.sleep(500);
    new Thread(()->{
        System.out.println("change B->A "+ref.compareAndSet("B","A"));
    }).start();
}

change
change A->B true
change B->A true
change A->C true

change
change A->B stamp 0true
change B->A stamp 1true
change A->C stamp 0false

change
change A->A mark true
change A->C mark false

10
20
20

public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[getProbe() & m]) == null ||
            !(uncontended = a.cas(v = a.value, v + x)))
            longAccumulate(x, null, uncontended);
    }
}

public class UnsafeAccessor {
    static Unsafe unsafe;
    static {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
    static Unsafe getUnsafe() {
        return unsafe;
    }
    public static void main(String[] args) throws NoSuchFieldException {
        Unsafe unsafe = UnsafeAccessor.getUnsafe();
        Field id = Student.class.getDeclaredField("id");
        Field name = Student.class.getDeclaredField("name");
        //获得成员变量的偏移量
        long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
        long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);
        Student student = new Student();
        //使用CAS方法替换成员变量的值
        UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20);       //返回true
        UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "张三");   //返回true
        System.out.println(student);
    }
}
class Student {
    volatile int id;
    volatile  String name;
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Student() {
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}