java锁相关（CAS的问题)

最新推荐文章于 2024-04-19 18:16:13 发布

qq_40757662

最新推荐文章于 2024-04-19 18:16:13 发布

阅读量122

点赞数

分类专栏：多线程高性能编程

本文链接：https://blog.csdn.net/qq_40757662/article/details/104805459

版权

多线程高性能编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

CAS的三大问题

上面我们在学习多线程的原子操作时提到了可以使用java里面的atomic来完成多线程的计算，但是cas也有一些问题：

1、循环+CAS，自旋的实现让所有线程处于高速运行，争抢cpu执行时间的状态。如果操作长时间不成功，会带来很大的cpu资源消耗。

2、仅针对单个变量的操作，不能用于多个变量来实现原子操作。

3、ABA问题。

ABA问题，线程1 从内存当中获取到变量V的值是A，线程2也从内存当中获取到V的值A，然后线程2将V的值修改成B, 然后线程2又将变量V的值改成了A，这时候线程1 判断变量V的值也是A，然后就进行修改成功了。

这个时候可能就会有个疑问即使我中间变化了，可我最终还是把值给改成我所期待的值，并不会有影响，这种想法只是在修改一个Integer类型时，可能中间修改过多少次并没有太大的影响，但是如果是链表的话，那么这个影响是很大的：

package com.study.cas.aba;

// 存储在栈里面元素 -- 对象
public class Node {
    public final String value;
    public Node next;

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

    @Override
    public String toString() {
        return "value=" + value;
    }
}

package com.study.cas.aba;

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

// 实现一个 栈（后进先出）
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) {

        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作为值返回
    }
}

package com.study.cas.aba;

import java.util.concurrent.locks.LockSupport;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Stack stack = new Stack();

        stack.push(new Node("B"));      //B入栈
        stack.push(new Node("A"));      //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);      //取出A
            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"));      //D入栈
            stack.push(new Node("C"));      //C入栈
            stack.push(nodeA);                    //A入栈

            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想要将栈顶的A替换成B，但是线程2比1快，线程2先行将A的next替换成C、D，然后线程1进行比较，发现栈顶都是A，然后将next元素替换成B，这样，C、D就出栈了，这样就造成了数据丢失的情况。

这是因为比较条件不够充分的原因（只比较旧值），使用AtomicStampedReference加版本号可以解决这个问题，代码如下：

package com.study.cas.aba;

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

public class ConcurrentStack {
    // top cas无锁修改
    //AtomicReference<Node> top = new AtomicReference<Node>();
    AtomicStampedReference<Node> top =
            new AtomicStampedReference<>(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)); // CAS 替换栈顶
    }


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

        Node newTop;
        Node oldTop;
        int v;

        do {
            v = top.getStamp();
            oldTop = top.getReference();
            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));     //将下一个节点设置为top
        return oldTop;      //将旧的Top作为值返回
    }
}