Java并发编程之cas理论(无锁并发)

文章目录

1、共享模型之无锁

  • Java中 synchronized 和 ReentrantLock 等 独占锁 就是 悲观锁 思想的实现
  • 在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的
  • 管程即monitor是阻塞式的悲观锁实现并发控制,这章我们将通过非阻塞式的乐观锁的来实现并发控制

2、有锁无锁模式对比

题目:共享资源10000元钱,1000个并发,每个10元,结果共享资源剩余为0

使用synchronized保证线程安全

/**
 * Description: 使用重量级锁synchronized来保证多线程访问共享资源发生的安全问题
 */
public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));//有锁模式
        //Account.demo(new AccountCas(10000));//无锁模式
    }
}

class AccountUnsafe implements Account {
    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        synchronized (this) {
            return balance;
        }
    }

    @Override
    public void withdraw(Integer amount) {
        // 通过这里加锁就可以实现线程安全,不加就会导致线程安全问题
        synchronized (this) {
            balance -= amount;
        }
    }
}

interface Account {
    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * Java8之后接口新特性, 可以添加默认方法
     * 方法内会启动 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");
    }
}
  • 上面的代码中使用synchronized加锁操作来保证线程安全,但是 synchronized加锁操作太耗费资源 (因为底层使用了操作系统mutex指令, 造成内核态和用户态的切换)

使用无锁来解决此问题

class AccountCas implements Account {
	//使用原子整数: 底层使用CAS+重试的机制
	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;
			//比较并设置值
			/*
				此时的prev为共享变量的值, 如果prev被别的线程改了
				也就是说: 自己读到的共享变量的值 和 共享变量最新值 不匹配,
				就继续where(true),如果匹配上了, 将next值设置给共享变量.
				
				AtomicInteger中value属性, 被volatile修饰, 就是为了确保线程之间共享变量的可见性.
			*/
			if(balance.compareAndSet(prev, next)) {
				break;
			}
		}
	}
}

3、 CAS 与 volatile

  • 使用原子操作来保证线程访问共享资源的安全性, cas+重试的机制来确保(乐观锁思想)
  • 相对于悲观锁思想的synchronized,reentrantLock来说, cas的方式效率会更好

3.1、cas + 重试 的原理

前面看到的AtomicInteger的解决方法,内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢?

@Override
public void withdraw(Integer amount) {
    // 核心代码
    // 需要不断尝试,直到成功为止
    while (true){
        // 比如拿到了旧值 1000
        int prev = balance.get();
        // 在这个基础上 1000-10 = 990
        int next = prev - amount;
        /*
         compareAndSet 保证操作共享变量安全性的操作:
         ① 线程A首先获取balance.get(),拿到当前的balance值prev
         ② 根据这个prev值 - amount值 = 修改后的值next
         ③ 调用compareAndSet方法, 首先会判断当初拿到的prev值,是否和现在的
         	balance值相同;
         	3.1、如果相同,表示其他线程没有修改balance的值, 此时就可以将next值
         		设置给balance属性
         	3.2、如果不相同,表示其他线程也修改了balance值, 此时就设置next值失败, 
				然后一直重试, 重新获取balance.get()的值,计算出next值,
				并判断本次的prev和balnce的值是否相同...重复上面操作
		*/
        if (atomicInteger.compareAndSet(prev,next)){
            break;
        }
    }
}
  • 其中的关键是 compareAndSwap(比较并设置值),它的简称就是 CAS (也有 Compare And Swap 的说法),它必须是原子操作

Java并发编程之cas理论(无锁并发)
流程 :

  • 当一个线程要去修改Account对象中的值时,先获取值prev(调用get方法),然后再将其设置为新的值next(调用cas方法)。在调用cas方法时,会将prev与Account中的余额进行比较
  • 如果两者相等,就说明该值还未被其他线程修改,此时便可以进行修改操作
  • 如果两者不相等,就不设置值,重新获取值prev(调用get方法),然后再将其设置为新的值next(调用cas方法),直到修改成功为止

注意 :

  • 其实 CAS 的底层是 lock cmpxchg 指令(X86 架构),在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的 原子性
  • 在多核状态下,某个核执行到带 lock 的指令时,CPU 会让总线锁住,当这个核把此指令执行完毕,再开启总线。这个过程中不会被线程的调度机制所打断,保证了多个线程对内存操作的准确性,是原子的

3.2、volatile的作用

  • 在上面代码中的AtomicInteger类,保存值的value属性使用了volatile 修饰。获取共享变量时,为了保证该变量的可见性,需要使用 volatile 修饰
  • volatile可以用来修饰 成员变量和静态成员变量,他可以避免线程从自己的工作缓存中查找变量的值,必须到主存中获取它的值,线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改,对另一个线程可见
  • cas必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果
  • volatile 仅仅保证了共享变量的可见性,让其它线程能够看到最新值,但不能解决指令交错问题(不能保证原子性

3.3、为什么CAS+重试(无锁)效率高

  • 使用CAS+重试—无锁情况下,即使重试失败,线程始终在高速运行,没有停歇,而 synchronized会让线程在没有获得锁的时候,发生上下文切换,进入阻塞
      1)打个比喻:线程就好像高速跑道上的赛车,高速运行时,速度超快
      2)一旦发生上下文切换,就好比赛车要减速、熄火,等被唤醒又得重新打火、启动、加速… 恢复到高速运行,代价比较大
  • 但无锁情况下,因为线程要保持运行,需要额外 CPU 的支持,CPU 在这里就好比高速跑道,没有额外的跑道,线程想高速运行也无从谈起,虽然不会进入阻塞,但由于没有分到时间片,仍然会进入可运行状态,还是会导致上下文切换

3.4、CAS 的特点 (乐观锁和悲观锁的特点)

结合 CAS 和 volatile 可以实现无锁并发,适用于线程数少、多核 CPU 的场景下

  • CAS 是基于乐观锁的思想:最乐观的估计,不怕别的线程来修改共享变量,就算改了也没关系,我吃亏点再重试
  • synchronized 是基于悲观锁的思想:最悲观的估计,得防着其它线程来修改共享变量,我上了锁你们都别想改,我改完了解开锁,你们才有机会
  • CAS 体现的是无锁并发、无阻塞并发,请仔细体会这两句话的意思
      1)因为没有使用 synchronized,所以线程不会陷入阻塞,这是效率提升的因素之一
      2)但如果竞争激烈(写操作多),可以想到重试必然频繁发生,反而效率会受影响

4、原子整数 (内部通过CAS来实现-AtomicInteger)

  • java.util.concurrent.atomic并发包提供了一些并发工具类
  • 使用原子的方式 (共享数据为基本数据类型原子类)
      1)AtomicInteger:整型原子类
      2)AtomicLong:长整型原子类
      3)AtomicBoolean :布尔型原子类
    上面三个类提供的方法几乎相同,所以我们将以 AtomicInteger为例子来介绍。
  • 先讨论原子整数类,以 AtomicInteger 为例讨论它的api接口:通过观察源码可以发现
  • AtomicInteger 内部都是通过cas的原理来实现的
public static void main(String[] args) {
    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));
    
    // int类型加减乘除操作
    // 获取并更新(i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0)
    // 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
    System.out.println(i.getAndUpdate(p -> p - 2));
    
    // int类型加减乘除操作
    // 更新并获取(i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0)
    // 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
    System.out.println(i.updateAndGet(p -> p + 2));
}

updateAndGet实现原理

public static void main(String[] args) {

	AtomicInteger i = new AtomicInteger(5);
	
    updateAndGet(i, new IntUnaryOperator() {
        @Override
        public int applyAsInt(int operand) {
            return operand / 2;
        }
    });
    System.out.println(i.get()); // 2
}

public static void updateAndGet(AtomicInteger i, IntUnaryOperator operator) {
    while (true) {
        int prev = i.get(); // 5
        int next = operator.applyAsInt(prev);
        if (i.compareAndSet(prev, next)) {
            break;
        }
    }
}

5、原子引用 (AtomicReference)

为什么需要原子引用类型?保证引用类型的共享变量是线程安全

  • AtomicReference:引用类型原子类
  • AtomicMarkableReference:原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来
  • AtomicStampedReference :原子更新带有版本号的引用类型。该类将整数值与引用关联起来,可用于解决原子的更新数据和数据的版本号,可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题

使用原子引用实现BigDecimal存取款的线程安全

public class Test {
    //原子BigDecimal引用,总额10000
    private static final AtomicReference<BigDecimal> balance
            = new AtomicReference<>(new BigDecimal("10000"));
    public static void main(String[] args) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            //循环创建1000个线程
            ts.add(new Thread(() -> {
                //每个线程从总额加去10,减法失败则一直while循环重试
                while (true) {
                    BigDecimal prev = balance.get();
                    BigDecimal next = prev.subtract(new BigDecimal("10"));
                    if (balance.compareAndSet(prev, next)) {
                        break;
                    }
                }
            }));
        }
        //启动1000个线程
        ts.forEach(Thread::start);
        //等待1000个线程执行完,main线程再执行
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //获取总额
        System.out.println(balance);
    }
}

5.1、ABA 问题及解决

  • 如下程序所示,虽然 在other方法中存在两个线程对共享变量进行了修改,但是修改之后又变成了原值,main线程对修改过共享变量的过程是不可见的,这种操作这对业务代码并无影响。
public class Test3 {
    public static AtomicReference<String> ref = new AtomicReference<>("A");
    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.get();
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把ref中的A改为C
            System.out.println("change A->C " + ref.compareAndSet(pre, "C"));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            // 此时ref.get()为A,此时共享变量ref也是A,没有被改过, 此时CAS
            // 可以修改成功, B
            System.out.println("change A->B " + ref.compareAndSet(ref.get(), "B"));
        }).start();
        Thread.sleep(500);
        new Thread(() -> {
            // 同上, 修改为A
            System.out.println("change B->A " + ref.compareAndSet(ref.get(), "A"));
        }).start();
    }
}

运行结果:

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

Process finished with exit code 0
  • 主线程仅能判断出共享变量的值与最初值 A是否相同,不能感知到这种从 A 改为 B 又改回 A 的情况
  • 判断值是否相同,是通过地址值==判断
  • 如果主线程希望:只要有其它线程【动过】共享变量,那么自己的 cas 就算失败
  • 这时,仅比较值是不够的,需要再加一个版本号。使用AtomicStampedReference来解决

5.2、AtomicStampedReference (加版本号解决ABA问题)

public class Test {
    //指定版本号
    public static AtomicStampedReference<String> ref 
            = new AtomicStampedReference<>("A", 0);
    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.getReference();
            //获得版本号
            int stamp = ref.getStamp(); // 此时的版本号还是第一次获取的
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把ref中的A改为C,并比对版本号,如果版本号相同,就执行替换,并让版本号+1
            System.out.println("change A->C stamp " + 
            stamp + ref.compareAndSet(pre, "C", stamp, stamp + 1));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            int stamp = ref.getStamp();
            System.out.println("change A->B stamp " + 
            stamp + ref.compareAndSet(ref.getReference(), "B", stamp, stamp + 1));
        }).start();
        Thread.sleep(500);
        new Thread(() -> {
            int stamp = ref.getStamp();
            System.out.println("change B->A stamp " + 
            stamp + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
        }).start();
    }
}

运行结果:

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

Process finished with exit code 0

5.3、AtomicMarkableReference (标记cas的共享变量是否被修改过)

  • AtomicStampedReference 可以给原子引用加上版本号,追踪原子引用整个的变化过程,如:A -> B -> A ->C,通过AtomicStampedReference,我们可以知道,引用变量中途被更改了几次
  • 但是有时候,并不关心引用变量更改了几次,只是单纯的关心是否更改过(true/false),所以就有了AtomicMarkableReference
public class Test {
    //指定标记,起始为true,当变为fals,则证明修改过
    public static AtomicMarkableReference<String> ref =
            new AtomicMarkableReference<>("A", true);

    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.getReference();
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把str中的A改为C,并比对版本号,如果版本号相同,就执行替换,并让版本号+1
            System.out.println("change A->C mark " +
                    ref.compareAndSet(pre, "C", true, false));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            System.out.println("change A->A mark " + ref.compareAndSet(
                    ref.getReference(), "A", true, false));
        }).start();
    }
}

执行结果:

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

Process finished with exit code 0

5.4、AtomicStampedReference和AtomicMarkableReference两者的区别

  • AtomicStampedReference 需要我们传入整型变量 作为版本号,来判定是否被更改过
  • AtomicMarkableReference需要我们传入布尔变量 作为标记,来判断是否被更改过

6、原子数组 (AtomicIntegerArray)

  • 保证数组内的元素的线程安全
  • 使用原子的方式更新数组里的某个元素
      1)AtomicIntegerArray:整形数组原子类
      2)AtomicLongArray:长整形数组原子类
      3)AtomicReferenceArray:引用类型数组原子类

上面三个类提供的方法几乎相同,所以我们这里以 AtomicIntegerArray 为例子来介绍

普通数组内元素, 多线程访问造成安全问题

  • 创建一个数组,10个元素
  • 创建10个线程,每个线程对数组每个元素操作10000次
  • 每次为每个元素+1
public class AtomicArrayTest {
    public static void main(String[] args) {
        demo(
            () -> new int[10],
            array -> array.length,
            (array, index) -> array[index]++,
            array -> System.out.println(Arrays.toString(array))
        );
    }
    /**
     * 参数1,提供数组、可以是线程不安全数组或线程安全数组
     * 参数2,获取数组长度的方法
     * 参数3,自增方法,回传 array, index
     * 参数4,打印数组的方法
     */
    // supplier 提供者 无中生有 ()->结果
    // function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
    // consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
    private static <T> void demo(Supplier<T> arraySupplier, Function<T, Integer> lengthFun,
                                 BiConsumer<T, Integer> putConsumer, Consumer<T> printConsumer) {
        List<Thread> ts = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);

        for (int i = 0; i < length; i++) {
            // 创建10个线程, 每个线程对数组作 10000 次操作
            ts.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }
        // 启动所有线程
        ts.forEach(Thread::start);
        // 等所有线程结束,再执行main线程
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        printConsumer.accept(array);
    }
}

执行结果:

[8374, 8170, 8091, 8031, 8029, 7981, 8276, 8405, 8434, 8504]

Process finished with exit code 0

使用AtomicIntegerArray来创建安全数组

demo(
        ()-> new AtomicIntegerArray(10),
        (array) -> array.length(),
        (array, index) -> array.getAndIncrement(index),
        array -> System.out.println(array)
);

执行结果:

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

Process finished with exit code 0

7、字段更新器

保证多线程访问同一个对象的成员变量时, 成员变量的线程安全性

  • AtomicReferenceFieldUpdater —引用类型的属性
  • AtomicIntegerFieldUpdater —整形的属性
  • AtomicLongFieldUpdater —长整形的属性

注意:利用字段更新器,可以针对对象的某个域(Field)进行原子操作,只能配合 volatile 修饰的字段使用,否则会出现异常

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

示例

public class AtomicFieldTest {
    public static void main(String[] args) {
        Student stu = new Student();
        // 获得原子更新器
        // 泛型
        // 参数1 持有属性的类 参数2 被更新的属性的类
        // newUpdater中的参数:第三个为属性的名称
        AtomicReferenceFieldUpdater updater = 
                AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        // 期望的为null, 如果name属性没有被别的线程更改过, 默认就为null, 此时匹配, 就可以设置name为张三
        System.out.println(updater.compareAndSet(stu, null, "张三"));
        System.out.println(updater.compareAndSet(stu, stu.name, "王五"));
        System.out.println(stu);
    }
}

class Student {
    volatile String name;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

运行结果:

true
true
Student{name='王五'}

Process finished with exit code 0

8、原子累加器 (LongAddr)

  • LongAddr
  • LongAccumulator
  • DoubleAddr
  • DoubleAccumulator

累加器性能比较 AtomicLong, LongAddr

public class Test {
    public static void main(String[] args) {
        System.out.println("----AtomicLong----");
        demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());

        System.out.println("----LongAdder----");
        demo(() -> new LongAdder(), adder -> adder.increment());
    }

    private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
        T adder = adderSupplier.get();
        long start = System.nanoTime();
        List<Thread> ts = new ArrayList<>();
        // 40 个线程,每人累加 50 万
        for (int i = 0; i < 40; i++) {
            ts.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(adder);
                }
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(adder + " 耗时:" + (end - start) / 1000_000);
    }
}

运行结果:

----AtomicLong----
20000000 耗时:390
----LongAdder----
20000000 耗时:44

Process finished with exit code 0
  • LongAddr:性能提升的原因很简单,就是在有竞争时,设置多个累加单元(但不会超过cpu的核心数),Therad-0 累加 Cell[0],而 Thread-1 累加Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量,因此减少了 CAS 重试失败,从而提高性能
  • AtomicLong:都是在一个共享资源变量上进行竞争, while(true)循环进行CAS重试, 性能没有LongAdder高

9、Unsafe

  • Unsafe 对象提供了非常底层的,操作内存、线程的方法,Unsafe 对象不能直接调用,只能通过反射获得
  • 可以发现AtomicInteger以及其他的原子类, 底层都使用的是Unsafe类

Java并发编程之cas理论(无锁并发)

底层的Unsafe实现原子操作

public class Test {
    public static void main(String[] args) throws Exception {
        // 通过反射获得Unsafe对象
        Class<Unsafe> unsafeClass = Unsafe.class;
        // 获得构造函数,Unsafe的构造函数为私有的
        Constructor<Unsafe> constructor = unsafeClass.getDeclaredConstructor();
        // 设置为允许访问私有内容
        constructor.setAccessible(true);
        // 创建Unsafe对象
        Unsafe unsafe = constructor.newInstance();

        // 创建Person对象
        Person person = new Person();
        // 获得其属性 name 的偏移量
        long nameOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("name"));
        long ageOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("age"));

        // 通过unsafe的CAS操作改变值
        unsafe.compareAndSwapObject(person, nameOffset, null, "guizy");
        unsafe.compareAndSwapInt(person, ageOffset, 0, 22);
        System.out.println(person);
    }
}

class Person {
    // 配合CAS操作,必须用volatile修饰
    volatile String name;
    volatile int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

运行结果:

Person{name='guizy', age=22}

Process finished with exit code 0

9.1、AtomicInteger累加源码

以AtomicInteger类incrementAndGet()方法(int+1返回更新值)为例

public class Test {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(10);
        int i1 = i.incrementAndGet();
        System.out.println(i1);
    }
}

运行结果:

11

Process finished with exit code 0

源码分析

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // 获取Unsafe类
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // 通过Unsafe类获取value偏移量
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * 累加1,并返回累加后的int值
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    /**
     * this:本对象,即toString(),这里即为int值
     */
    public String toString() {
        return Integer.toString(get());
    }

    /**
     * 获取value值
     */
    public int intValue() {
        return get();
    }
}

unsafe.getAndAddInt(this, valueOffset, 1)方法

  • var1:this,这里则为10
  • var2:valueOffset(value值的偏移量)
  • var4:累加,即这里为1
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
    	//通过value值的偏移量获取value的最新值
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}
  • compareAndSwapInt:通过偏移值获取最新value值与之前获取的当时最新值var5比较
  • 如果相同,则将value值+var4(这里是1),!compareAndSwapInt=false,跳出循环
  • 如果不同,value+1失败,!compareAndSwapInt=true,继续进入do循环去获取最新值
上一篇:PE结构-DOS头


下一篇:Dos系统