线程安全之原子性问题

深碍√TFBOYSˉ_ 2023-07-06 14:47 39阅读 0赞

## 原子操作 ##

> 定义: 原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执  
> 行其中的一部分

i++便不是原子操作

public class Counter {
        volatile int i = 0;
    
        public int getI() {
            return i;
        }
    
        public void add() {
            i++;
        }
    }

测试代码

public class Demo1_CounterTest {
        public static void main(String[] args) throws InterruptedException {
            final Counter ct = new Counter();
    
            for (int i = 0; i < 6; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 0; j < 10000; j++) {
                            ct.add();
                        }
                        System.out.println("done...");
                    }
                }).start();
            }
    
            Thread.sleep(6000L);
            System.out.println(ct.getI());
        }
    }

预计应该是打印i的值为60000  
而实际上  
![在这里插入图片描述][20200220102747156.png]  
i++ 便存在竞态条件

**竞态条件**

> 当某个计算的正确性取决于多个线程的交替执行时序时,那么就会发生竞态条件.换句话说,就是正确的结果要取决于运气.  
> 也就是说,如果两个线程竞争同一资源时,如果对资源的访问顺序敏感, 就称存在竞态条件

## 解决办法 ##

### 1.同步锁 ###

示例代码:

public class CounterLock {
        volatile int i = 0;
    
        Lock lock = new ReentrantLock();
    
        public void add() {
            lock.lock();
            i++;
            lock.unlock();
        }
    }

或者

public class CounterSync {
        volatile int i = 0;
    
        public synchronized void add() {
            i++;
        }
    }

### 2.CAS ###

**CAS(Compare and swap) 机制**

> 1.CAS 属于硬件同步原语，处理器提供的内存操作指令，保证原子性。  
> 2.CAS 操作需要两个参数，一个旧值和一个目标值，修改前先比较旧值是否改变，如果没变，将新值赋给变量，否则不做改变。  
> 3.JAVA中sun.misc.Unsafe类提供了CAS机制

**Unsafe使用示例**

public class CounterUnsafe {
    
        int i = 0;
    
        public int getI() {
            return i;
        }
    
        //Unsafe可以修改对象的属性、可以修改数组等等
        private static Unsafe unsafe = null;
    
        //一个偏移量,代表了要修改的字段
        private static long valueOffset;
    
        static {
            try {
                Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
                // 暴力反射
                theUnsafe.setAccessible(true);
                unsafe = (Unsafe) theUnsafe.get(null);
    
                //指定要修改的字段
                Field iFiled = CounterUnsafe.class.getDeclaredField("i");
                valueOffset = unsafe.objectFieldOffset(iFiled);
    
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    
        public void add() {
            while (true) {
                if (unsafe.compareAndSwapInt(this, valueOffset, i, i + 1)) {
                    return;
                }
            }
        }
    
    }

**CAS存在的问题**

> 1.不能用于多个变量来实现原子操作  
> 2.循环CAS自旋让所有线程都处于高频运行,争抢CPU执行.如果长时间不成功,则会带来很大的CPU资源消耗  
> 3.ABA问题 (在多线程环境中，使用CAS时，如果一个线程对变量修改2次，第2次修改后的值和第1次修改前的值相同，那么可能就会出现ABA问题  
> )

**J.U.C包内的原子操作封装类**

> 常用的数据类型的原子操作封装类:  
> AtomicBoolean: 原子更新布尔类型  
> AtomicInteger：原子更新整型  
> AtomicLong：原子更新长整型

如果将上面示例代码的int i = 0 改为原子操作封装类

public class CounterAtomic {
        AtomicInteger at = new AtomicInteger(0);
    
        public void add(){
            // CAS操作进行累加
            at.getAndIncrement();
        }
    
        public int getValue(){
            return at.get();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODE1MTIy_size_16_color_FFFFFF_t_70]  
则可以打印出和预计值一样的60000

> 数组的原子操作封装类  
> AtomicIntegerArray：原子更新整型数组里的元素。  
> AtomicLongArray：原子更新长整型数组里的元素。  
> AtomicReferenceArray：原子更新引用类型数组里的元素。

> 更新器  
> AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。  
> AtomicLongFieldUpdater：原子更新长整型字段的更新器。  
> AtomicReferenceFieldUpdater：原子更新引用类型里的字段。

使用示例:

public class Demo_AtomicIntegerFieldUpdater {
        // 新建AtomicIntegerFieldUpdater对象，需要指明是哪个类中的哪个字段
        private static AtomicIntegerFieldUpdater<User> atom =
                AtomicIntegerFieldUpdater.newUpdater(User.class, "id");
    
        public static void main(String[] args) {
            User user = new User(100, 100);
            atom.addAndGet(user, 50);
            System.out.println("atom.addAndGet(user, 50)值变为：" + user);
        }
    }
    
    class User {
        
        volatile int id;
        volatile int age;
        
        public User(int id, int age) {
            this.id = id;
            this.age = age;
    
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

> 原子更新引用类型  
> AtomicReference：原子更新引用类型。  
> AtomicStampedReference：原子更新带有版本号的引用类型  
> AtomicMarkableReference：原子更新带有标记位的引用类型。

> 原子计数器  
> DoubleAdder、 LongAdder:计数器增强版，高并发下性能更好  
> DoubleAccumulator、 LongAccumulator: 是计数器的增强版，可自定义累加规则

使用示例:

public class Demo_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());
        }
    }

[20200220102747156.png]: https://img-blog.csdnimg.cn/20200220102747156.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODE1MTIy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200220130011704.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODE1MTIy,size_16,color_FFFFFF,t_70