java并发原理实战(7) -- 原子类使用和原理理解

使用

原子更新基本类型

原子更新数组

原子更新抽象类型

原子更新字段

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)这样即可以保证原子写入。

摘自文章：https://blog.csdn.net/doujinlong1/article/details/81584045

完