使用
原子更新基本类型
原子更新数组
原子更新抽象类型
原子更新字段
public class Sequence { private int value; public int getNext() { return value++; } public static void main(String[] args) { Sequence sequence = new Sequence(); // while (true){ // System.out.println(sequence.getNext()); // } new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); } }
运行结果:
会看到：多个线程对value++，出现了 value一样的情况，即多线程安全问题。
用原子类解决下：
public class Sequence { private AtomicInteger value = new AtomicInteger(0); public int getNext() { return value.getAndIncrement(); } public static void main(String[] args) { Sequence sequence = new Sequence(); new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); new Thread(() -> { while (true) { System.out.println(Thread.currentThread().getName() + " " + sequence.getNext()); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } ).start(); } }
运行结果:
发现没有安全性问题。
原子类AtomicInteger原理
在Java中，有很多方法可以保证多线程下数据的安全，AtomicXXXX这些类就是其中的一种，原子类，可以保证每一步操作都是原子操作。这次就对AtomicInteger的源码进行学习。
首先看一下这个类的类变量和成员变量:
//类变量 unsafe类【java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作】 //这里的这个变量就是用来进行cpu级别的原子操作。 private static final Unsafe unsafe = Unsafe.getUnsafe(); //这个变量实际上是由下面的static块来赋值的，可以由赋值看出来，这个值是下面的value属性在每个AtomikInteger对象中的位置偏移量，用这个值既可以找到在具体每个对象的内存中的内存地址。 private static final long valueOffset; static { try { valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } //volatile修饰，AtomicInteger的值，在直接内存中，多个线程下可以直接获取值。 private volatile int value;
看完了这个类的内部的变量，其实大概可以猜到这个类怎么完成的原子操作了，使用volatile修饰的value来存储值，保证每个线程都可以随时读到值，然后每一步操作都使用CAS(compare and swap)这样即可以保证一直能原子写入，下面来看看源码到底是不是这样。
来看一下incrementAndGet这个方法，实际上就是++i的操作，但是保证原子性。
public final int incrementAndGet() { //用get出来的值+1，前面的方法是unsafe中实现的 i++。对value属性进行操作。 return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } //Unsafe中的。这个方法可以看到一直在做do-while，直到CAS成功（获取AtomicInteger对象上的value属性,然后CAS检查保证值是var5的时候将他变成var5+1）。 //其中getIntVolatile和compareAndSwapInt 都是native方法，用C写的。CAS底层貌似是使用了cpu的cpxchg(compare*change)。 public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; }
总结
所有其他的方法都大同小异，使用volatile修饰的value来存储值，保证每个线程都可以随时读到值，然后每一步操作都使用CAS(compare and swap)这样即可以保证原子写入。
完
