java并发编程之原子操作

　　先来看一段简单的代码，稍微有点并发知识的都可以知道打印出结果必然是一个小于20000的值

package com.example.test.cas;

import java.io.IOException;

/**
 * @author hehang on 2019-10-09
 * @description
 */
public class LockDemo {


    private volatile  int i;

    public void add(){
        i++;
    }

    public static void main(String[] args) throws IOException {

        LockDemo lockDemo = new LockDemo();
        for (int i = 0; i <2 ; i++) {
            new Thread(() ->{
                for (int j = 0; j <10000 ; j++) {
                    lockDemo.add();
                }
            }).start();
        }
        System.in.read();
        System.out.println(lockDemo.i);
    }
}

　　改进一下，使用jdk给我们提供的原子操作类，达到了我们预想的结果

package com.example.test.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author hehang on 2019-10-14
 * @description
 */
public class AtomicTest {
    public static void main(String[] args) throws InterruptedException {
        // 自增
        AtomicInteger atomicInteger = new AtomicInteger(0);
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    atomicInteger.incrementAndGet();
                }
            }).start();
        }
        Thread.sleep(2000L);
        System.out.println(atomicInteger.get());
    }
}

　　下面就来探究下jdk为我们提供的原子操作类的原理，基于java native方法实现一个自己原子操作类

package com.example.test.cas;

import sun.misc.Unsafe;

import java.io.IOException;
import java.lang.reflect.Field;

/**
 * @author hehang on 2019-10-09
 * @description
 */
public class LockCASDemo {


    private volatile  int i;

    private static Unsafe unsafe;

    private static long offset;
    static{
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
            offset = unsafe.objectFieldOffset(LockCASDemo.class.getDeclaredField("i"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public void add(){
        int curent;
        int value;
        do{
            curent = unsafe.getIntVolatile(this,offset);
            value = curent+1;
        }while (!unsafe.compareAndSwapInt(this,offset,curent,value));
    }

    public static void main(String[] args) throws IOException {

        LockCASDemo lockDemo = new LockCASDemo();
        for (int i = 0; i <2 ; i++) {
            new Thread(() ->{
                for (int j = 0; j <10000 ; j++) {
                    lockDemo.add();
                }
            }).start();
        }
        System.in.read();
        System.out.println(lockDemo.i);
    }
}

　　实现这样一个类的要点有：1、基于反射机制获取UnSafe对象2、利用UnSafe对象获取属性偏移量，然后调用compareAndSwapInt方法，比较和替换是硬件同步原语，处理器提供了基于内存操作的原子性保证。

　　以上的代码未免麻烦，因此jdk为我们封装了一些原子操作类来简化使用，打开这些原子操作类的源代码，可以发现其内部实现就是循环+调用native方法(比较替换)，常用的原子操作类如下：

　　cas存在的三个问题

　　1、循环+cas，自旋的实现让cpu处于高频运行状态，争抢cpu执行时间，如果并发太高，部分线程长时间执行不成功，带来很大的cpu消耗

　　2、只能针对单个变量实现原子操作

　　3、出现ABA问题

　　针对第一个问题，jdk1.8为我们提供了增强版的计数器，内部利用分而治之的思想来减少线程间的cpu争抢，提高并发效率，具体可以看下面的测试

package com.example.test.cas;

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author hehang on 2019-10-14
 * @description asd
 */
public class LongAdderDemo {
    private long count = 0;

    // 同步代码块的方式
    public void testSync() throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                long starttime = System.currentTimeMillis();
                while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒
                    synchronized (this) {
                        ++count;
                    }
                }
                long endtime = System.currentTimeMillis();
                System.out.println("SyncThread spend:" + (endtime - starttime) + "ms" + " v" + count);
            }).start();
        }
    }

    // Atomic方式
    private AtomicLong acount = new AtomicLong(0L);

    public void testAtomic() throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                long starttime = System.currentTimeMillis();
                while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒
                    acount.incrementAndGet(); // acount++;
                }
                long endtime = System.currentTimeMillis();
                System.out.println("AtomicThread spend:" + (endtime - starttime) + "ms" + " v-" + acount.incrementAndGet());
            }).start();
        }
    }

    // LongAdder 方式
    private LongAdder lacount = new LongAdder();
    public void testLongAdder() throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                long starttime = System.currentTimeMillis();
                while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒
                    lacount.increment();
                }
                long endtime = System.currentTimeMillis();
                System.out.println("LongAdderThread spend:" + (endtime - starttime) + "ms" + " v-" + lacount.sum());
            }).start();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LongAdderDemo demo = new LongAdderDemo();
        demo.testSync();
        demo.testAtomic();
        demo.testLongAdder();
    }
}

　　三种方式在同样的时间内，自增的数值如下，可以看到LongAdder的效率更高一些

SyncThread spend:2000ms v23074332
SyncThread spend:2000ms v23094924
AtomicThread spend:2000ms v-38137398
AtomicThread spend:2000ms v-38152694
SyncThread spend:2011ms v23094924
AtomicThread spend:2000ms v-38416095
LongAdderThread spend:2000ms v-40097562
LongAdderThread spend:2000ms v-40606405
LongAdderThread spend:2001ms v-40917467

Process finished with exit code 0

　　针对第二个问题，我们只能通过加锁或者其它手段其处理，这里不做展开

　　针对第三个问题，我们先模拟出以下的场景来展示这个问题

package com.example.test.cas.aba;

/**
 * @author hehang on 2019-10-14
 * @description
 */
public class Node {
    public final String item;
    public Node next;

    public Node(String item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "item内容:" + this.item;
    }
}

package com.example.test.cas.aba;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author hehang on 2019-10-14
 * @description
 */
// 实现一个 栈（后进先出）
public class Stack {
    // top cas无锁修改
    AtomicReference<Node> top = new AtomicReference<Node>();

    public void push(Node node) { // 入栈
        Node oldTop;
        do {
            oldTop = top.get();
            node.next = oldTop;
        }
        while (!top.compareAndSet(oldTop, node)); // CAS 替换栈顶
    }

    // 为了演示ABA效果， 增加一个CAS操作的延时
    public Node pop(int time) throws InterruptedException { // 出栈 -- 取出栈顶

        Node newTop;
        Node oldTop;
        do {
            oldTop = top.get();
            if (oldTop == null) {
                return null;
            }
            newTop = oldTop.next;
            if (time != 0) {
                System.out.println(Thread.currentThread() + " 休眠前拿到的数据" + oldTop.item);
                TimeUnit.SECONDS.sleep(time); // 休眠指定的时间
            }
        }
        while (!top.compareAndSet(oldTop, newTop));
        return oldTop;
    }
}

package com.example.test.cas.aba;

/**
 * @author hehang on 2019-10-14
 * @description
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Stack stack = new Stack();
        stack.push(new Node("B"));
        stack.push(new Node("A"));

        Thread thread1 = new Thread(() -> {
            try {
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(3));
                // 再继续拿，就会有问题了，理想情况stack出数据应该是 A->C->D->B，实际上ABA问题导致A-B->null
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        thread1.start();

        Thread.sleep(300); // 让线程1先启动

        Thread thread2 = new Thread(() -> {
            Node A = null;
            try {
                A = stack.pop(0);
                System.out.println(Thread.currentThread() + " 拿到数据：" + A);
                stack.push(new Node("D"));
                stack.push(new Node("C"));
                stack.push(A);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        thread2.start();
    }
}

　　在上面的例子中我们想实现一个栈，单线程情况下是没有任何问题的，但是在并发场景下就会出现丢数据的问题，运行结果：

Thread[Thread-0,5,main] 睡一下，预期拿到的数据A
Thread[Thread-1,5,main] 拿到数据：item内容:A
Thread[Thread-0,5,main] 拿到数据：item内容:A
Thread[Thread-0,5,main] 拿到数据：item内容:B
Thread[Thread-0,5,main] 拿到数据：null
Thread[Thread-0,5,main] 拿到数据：null

Process finished with exit code 0

　　好在jdk为我们考虑了这个问题，提供了AtomicStampedReference和AtomicMarkableReference，前者基于时间戳，后者基于标记位来对同样的数据做区分，从未避免了ABA问题

package com.example.test.cas.aba;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author hehang on 2019-10-14
 * @description
 */
public class ConcurrentStack {
    AtomicStampedReference<Node> top = new AtomicStampedReference<Node>(null,0);
    public void push(Node node){
        Node oldTop;
        int v;
        do{
            v=top.getStamp();
            oldTop = top.getReference();
            node.next = oldTop;
        }
        while(!top.compareAndSet(oldTop, node,v,v+1));
        //   }while(!top.compareAndSet(oldTop, node,top.getStamp(),top.getStamp()+1));
    }
    public Node pop(int time){
        Node newTop;
        Node oldTop;
        int v;
        do{
            v=top.getStamp();
            oldTop = top.getReference();
            if(oldTop == null){
                return null;
            }
            newTop = oldTop.next;
            try {
                if (time != 0) {
                    System.out.println(Thread.currentThread() + " 睡一下，预期拿到的数据" + oldTop.item);
                    TimeUnit.SECONDS.sleep(time); // 休眠指定的时间
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        while(!top.compareAndSet(oldTop, newTop,v,v+1));
        //   }while(!top.compareAndSet(oldTop, newTop,top.getStamp(),top.getStamp()));
        return oldTop;
    }
    public void get(){
        Node node = top.getReference();
        while(node!=null){
            System.out.println(node.item);
            node = node.next;
        }
    }
}

package com.example.test.cas.aba;

/**
 * @author hehang on 2019-10-14
 * @description
 */
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentStack stack = new ConcurrentStack();
        stack.push(new Node("B"));
        stack.push(new Node("A"));

        Thread thread1 = new Thread(() -> {
            try {
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(3));
                // #再继续拿，就会有问题了，理想情况stack出数据应该是 A->C->D->B，实际上ABA问题导致A-B->null
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
                System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0));
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        thread1.start();

        Thread.sleep(300); // 让线程1先启动

        Thread thread2 = new Thread(() -> {
            Node A = null;
            try {
                A = stack.pop(0);
                System.out.println(Thread.currentThread() + " 拿到数据：" + A);
                stack.push(new Node("D"));
                stack.push(new Node("C"));
                stack.push(A);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        thread2.start();
    }
}

　　结果如下：

Thread[Thread-0,5,main] 睡一下，预期拿到的数据A
Thread[Thread-1,5,main] 拿到数据：item内容:A
Thread[Thread-0,5,main] 睡一下，预期拿到的数据A
Thread[Thread-0,5,main] 拿到数据：item内容:A
Thread[Thread-0,5,main] 拿到数据：item内容:C
Thread[Thread-0,5,main] 拿到数据：item内容:D
Thread[Thread-0,5,main] 拿到数据：item内容:B

Process finished with exit code 0