private  static AtomicStampedReference money = new AtomicStampedReference(100,1);
    public static void main(String[] args) throws InterruptedException {
        //两次转账
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
               boolean resule1= money.compareAndSet(100,0,1,2);//旧值，新值，旧版本号，新版本号
                System.out.println(resule1);//true
            }
        });
        thread.start();
        //增加100
        Thread thread3= new Thread(new Runnable() {
            @Override
            public void run() {
                boolean resule2= money.compareAndSet(0,100,2,3);
                System.out.println(resule2);//true
            }
        });
        thread3.start();
        thread.join();
        thread3.join();
        Thread thread2= new Thread(new Runnable() {
            @Override
            public void run() {
                boolean resule2= money.compareAndSet(100,0,1,2);
                System.out.println(resule2);//false
            }
        });
        thread2.start();
        thread2.join();

    }

注意事项：AtomicReference有ABA问题AtomicStampedReference是解决ABA问题的.AtomicStampedReference它对比里面的旧值对比的是引用。
这里就有一个高速缓存机制，当取的值是范围里面的时，会直接按值对比，超过此范围就会对比地址。Integer（-128–127）

2》悲观锁

悲观锁是认为只要执行多线程就会出现问题，所以在进入方法后都会进行加锁。 悲观锁的实现就是synchronize。

（2）公平锁VS非公平锁：

公平锁：1；一个线程释放锁，2；主动唤醒需要得到锁的线程。
非公平锁：抢占式执行,当一个线程释放锁，另一个线程刚好执行到获取锁的代码就可以获取到锁。 使用new
ReentrantLock（true）来设置公平锁，默认是false，非公平锁，synchronize是非公平锁

（3）独占锁VS共享锁

独占锁：指的是这一把锁只能被这一个线程拥有。（synchronize）
共享锁：指的是这把锁可以被多个线程同时拥有。（ReadWriteLock中的读锁就是共享锁）将锁的粒度更加细化，从而提高锁的性能。

（4）可重入锁：

一个线程在拥有了一把锁后，可以重复的进入（synchronize，ReentrantLock）

private  static  Object object = new Object();

    public static void main(String[] args) {
        synchronized (object){
            System.out.println("进入主方法");
            synchronized (object){
                System.out.println("重复进入方法");
            }
        }
    }