Atomic 特殊标记类

左手的ㄟ右手 2022-12-19 15:25 93阅读 0赞

## 前言 ##

`JDK`提供了两个额外附加信息的`Atomic`帮助类,主要处理`ABA`类问题

1.  `AtomicMarkableReference`
2.  `AtomicStampedReference`

`AtomicMarkableReference`额外添加了一个`Boolean`字段在其中,可以根据业务场景使用,如避免`ABA`问题，可是视为`AtomicStampedReference`精简版。

`AtomicStampedReference`额外添加了一个`Long`类型字段在其中，可以避免`ABA`问题，甚至可以知道经过几次变化，相比`AtomicMarkableReference`更复杂，也具有更多的信息。

## `ABA`问题 ##

下面是一个常见的栈结构：  
请问下面多线程情况下，下面所谓的无锁编程否安全？

static class MyStack {
        
            AtomicReference<Node> headAtomic = new AtomicReference<>();
            
            public void push(Node node) {
        
                Node curr = headAtomic.get();
                node.next = curr;
                while (true) {
        
                    if (!headAtomic.compareAndSet(curr, node)) {
        
                        curr = headAtomic.get();
                        node.next = curr;
                    } else {
        
                        break;
                    }
                }
                //上面的等价于下面的
    //            headAtomic.updateAndGet(preNode -> {
        
    //                node.next = preNode;
    //                return node;
    //            });
    
            }
            
            public Node pop() {
        
                Node curr = headAtomic.get();
                if (curr == null) {
        
                    return null;
                }
                Node next = curr.next;
                while (true) {
        
                    if (!headAtomic.compareAndSet(curr, next)) {
        
                        curr = headAtomic.get();
                        next = curr.next;
                    } else {
        
                        break;
                    }
                }
                return curr;
            }
        }
    
        static class Node {
        
            // Node next;
            Node next;
    
            String name;
    
            public Node(String name) {
        
                this.name = name;
            }
            
            @Override
            public String toString() {
        
                return "Node{" +
                        "name='" + name + '\'' +
                        '}';
            }
        }

上面的代码会在多线程情况由于`ABA`问题导致链表错误。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]

当然上面只是一种情况，还有一种是位于pop函数`while(true)`之前出现`ABA`操作也会有同样的问题，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]

## AtomicStampedReference ##

我们看下其UML图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]

### 常用方法说明 ###

1.  `getReference`  
    得到其引用对象，但是不会返回时间戳
2.  `getStamp`  
    得到其时间戳对象
3.  `V get(int[] stampHolder)`  
    传入一个数组大小为1对象，时间戳放入数组的一个元素中能够，然后返回对象
    
        //构造一个对象，初始引用对象为null 时间戳为 0
                AtomicStampedReference<Cookies> stampedReference = new AtomicStampedReference<>(null, 0);
                int stampArray[]=new int[1];
                Cookies cookies = stampedReference.get(stampArray);
                //保存的时间戳
                System.out.println(stampArray[0]);
4.  `boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)`  
    常规的CAS操作，不同的是额外添加了一个时间戳对比
    
        //构造一个对象，初始引用对象为null 时间戳为 0
            AtomicStampedReference<Cookies> stampedReference = new AtomicStampedReference<>(null, 0);
            int stampArray[] = new int[1];
            Cookies oldData = stampedReference.get(stampArray);
        
            Boolean result = stampedReference.compareAndSet(oldData,//预期旧数据
                    new Cookies(), //新对象
                    stampArray[0],//预期旧的时间戳
                    stampArray[0] + 1//新的时间戳
            );

当预期的时间戳和预期旧对象相同时才可成功设置。

1.  `weakCompareAndSet`  
    完全等价compareAndSet，不要被weak误导
2.  `void set(V newReference, int newStamp)`  
    直接设置新的对象和新的时间戳
3.  `boolean attemptStamp(V expectedReference, int newStamp)`  
    如果当前引用等于传入的期待引用那么更新时间戳
    
        //构造一个对象，初始引用对象为null 时间戳为 0
                AtomicStampedReference<Cookies> stampedReference = new AtomicStampedReference<>(null, 0);
                int stampArray[] = new int[1];
        
                Cookies old = stampedReference.getReference();
        
                stampedReference.attemptStamp(old,222);

### 案例 ###

我们看下如何使用 这个类解决我们链表ABA问题的

static class MyStack {
        
            //        Node head;
            AtomicStampedReference<Node> headAtomic = new AtomicStampedReference<Node>(null, 0);
    
            public void push(Node node) {
        
                int[] stamp = new int[1];
                Node curr = headAtomic.get(stamp);
                node.next = curr;
    
                while (true) {
        
                    if (!headAtomic.compareAndSet(curr, node, stamp[0], stamp[0] + 1)) {
        
                        curr =  headAtomic.get(stamp);
                        node.next = curr;
                    } else {
        
                        break;
                    }
                }
    
    
            }
    
            public Node pop() {
        
                int[] stamp = new int[1];
    
                Node curr = headAtomic.get(stamp);
                if (curr == null) {
        
                    return null;
                }
                Node next = curr.next;
    
                while (true) {
        
                	//由于每次改动stamp都会加一，我们可以精准的知道经过了几次改动
                	//所以完全不需要当心改动的问题
                    if (headAtomic.compareAndSet(curr, next, stamp[0], stamp[0] + 1)) {
        
                        return curr;
                    } else {
        
                        curr = headAtomic.get(stamp);
                        next = curr.next;
                    }
                }
            }
        }

## `AtomicMarkableReference` ##

我们首先看下简单的使用案例:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 3]  
由于方法和`AtomicStampedReference`差不多，所以简单举例即可.

public class AtomicMArkableReferenceExample {
        
    
        private static Person person;
        private static AtomicMarkableReference<Person> aMRperson;
    
        public static void main(String[] args) throws InterruptedException {
        
    
            person = new Person(15);
            //构造一个初始化对象为 person ，标记为false
            aMRperson = new AtomicMarkableReference<Person>(person, false);
    
            boolean markeArray[] = new boolean[1];
    
            Person person = aMRperson.get(markeArray);
    
            //当旧的对象和旧的标记符合时才会使compareAndSet成功
            aMRperson.compareAndSet(person,//期待旧的对象
                    new Person(25),//放置新的对象
                    markeArray[0],//旧的对象标记
                    false);//设置新的标志
    
            
            System.out.println("Person is " + aMRperson.getReference() + "\nMark: "
                    + aMRperson.isMarked());
    
    
        }
    
        static class Person {
        
            private int age;
            public Person(int age) {
        
                this.age = age;
            }
            public int getAge() {
        
                return age;
            }
    
            public void setAge(int age) {
        
                this.age = age;
            }
    
            @Override
            public String toString() {
        
                return "Person age is " + this.age;
            }
        }
    
    }

## 参考： ##

[什么是ABA问题？][ABA]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/efca9b098dc84096aebcf94f1b4445da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/46fa819613fd4fe19127f1e1d23ceaa2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/e02b11e9d42f4f1781f29eb4bd3b902a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/999f2b99f54649ffab97c2f202ab03c0.png
[ABA]: https://www.zhihu.com/question/23281499