public long testLongAdder() throws InterruptedException 
        LongAdder lacount = new LongAdder();
        for (int i = 0; i < 3; i++) 
            new Thread(() -> 
                long starttime = System.currentTimeMillis();
                while (System.currentTimeMillis() - starttime < 2000)  // 运行两秒
                    lacount.increment();
                
                long endtime = System.currentTimeMillis();
            ).start();
        
        Thread.sleep(3000);
        return lacount.sum();
    

public class Demo3_LongAccumulator 
    public static void main(String[] args) throws InterruptedException 

        LongAccumulator accumulator = new LongAccumulator(
                (x,y)->
                    System.out.println("x:" + x);
                    System.out.println("y:" + y);
                    return  x+y;
                ,
                0L);

        for (int i = 0; i < 3; i++) 
            accumulator.accumulate(1);
        

        System.out.println(accumulator.get());

    

CAS存在的问题

• 仅针对单个变量的操作，不能用于多个变量来实现原子操作
• 循环+CAS,自旋的实现让所有线程都处于高频运行，争抢CPU执行时间的状态。如果操作长时间不成功，会消耗大量的cpu资源。

• ABA问题，无法体现出数据的变动。

主要是多线程操作时，其中一个线程操作过后，得到的新值

上述的方式，在automicinteger里面不出问题，在AtomicReference中可能出现问题，也是链表结构的情况

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 替换栈顶
    


    // 出栈
    public Node pop(int time) 

        Node newTop;
        Node oldTop;
        do 
            oldTop = top.get();
            if (oldTop == null)    //如果没有值，就返回null
                return null;
            
            newTop = oldTop.next;
            if (time != 0)     
                LockSupport.parkNanos(1000 * 1000 * time); 
            
        
        while (!top.compareAndSet(oldTop, newTop));     //将下一个节点设置为top
        return oldTop;      //将旧的Top作为值返回
    

 测试方法

 public static void main(String[] args) throws InterruptedException 
        Stack stack = new Stack();
        //ConcurrentStack stack = new ConcurrentStack();

        stack.push(new Node("B"));      
        stack.push(new Node("A"));      

        Thread thread1 = new Thread(() -> 
            Node node = stack.pop(800);
            System.out.println(Thread.currentThread().getName() +" "+ node.toString());

            System.out.println("done...");
        );
        thread1.start();

        Thread thread2 = new Thread(() -> 
            LockSupport.parkNanos(1000 * 1000 * 300L);

            Node nodeA = stack.pop(0);      
            System.out.println(Thread.currentThread().getName()  +" "+  nodeA.toString());

            Node nodeB = stack.pop(0);      //取出B，之后B处于游离状态
            System.out.println(Thread.currentThread().getName()  +" "+  nodeB.toString());

            stack.push(new Node("D"));      
            stack.push(new Node("C"));      
            stack.push(nodeA);                    

            System.out.println("done...");
        );
        thread2.start();

        LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);


        System.out.println("开始遍历Stack：");
        Node node = null;
        while ((node = stack.pop(0))!=null)
            System.out.println(node.value);
        
    

线程1在拿到 老的top值，和新的node值时过后，进行cas比较并赋值的情况等待状态了；然后线程2中间插入了很多数据，又插回了原来那个对象，因此出现了ABA问题。线程2put进去的数据都变不在了，其实里面属性已经变了

解决ABA问题的办法

主要是我们不能将top引用作为对比的对象，如果按照引用去对比，属性修改，数据肯定不正确了。

AtomicStampedReference<Node> top =
            new AtomicStampedReference<>(null, 0);

AtomicStampedReference添加了版本号，不只是对比引用，加入了版本号维护；

package org.cao.learn;

import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.LockSupport;

// 实现一个 栈（后进先出）
public class Stack 
	// top cas无锁修改
	AtomicStampedReference<Node> top = new AtomicStampedReference<Node>(null, 0);
//	AtomicReference<Node> top = new AtomicReference<Node>();

	public void push(Node node)  // 入栈
		Node oldTop;
		int v = 0;
		do 
			v = top.getStamp();
			oldTop = top.getReference();
			node.next = oldTop;
		 while (!top.compareAndSet(oldTop, node, v, v + 1)); // CAS 替换栈顶
	

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

		Node newTop;
		Node oldTop;
		int v = 0;
		do 
			oldTop = top.getReference();
			v = top.getStamp();
			if (oldTop == null)  // 如果没有值，就返回null
				return null;
			
			newTop = oldTop.next;
			if (time != 0)  // 模拟延时
				LockSupport.parkNanos(1000 * 1000 * time); 
			
		 while (!top.compareAndSet(oldTop, newTop, v, v + 1)); 
		return oldTop;