多线程编程（六）原子类

分手后的思念是犯贱 2022-12-21 06:12 143阅读 0赞

# 原子类 #

### 目录 ###

*  原子类
 *   *  1. 原子类分类
     *   *  1.1 原子基本类型
         *  1.2 原子数组类型
         *  1.3 原子引用类型
         *  1.4 原子属性类型
     *  2. 非原子类实例
     *  3. 原子类实例
     *  4. AtomicInteger 常用方法
     *  4. AtomicInteger 源码分析
     *  5. ABA问题
     *  6. ABA解决

## 1. 原子类分类 ##

> 原子类基本都在java.util.concurrent.atomic 包中

### 1.1 原子基本类型 ###

*  AtomicBoolean
 *  AtomicInteger
 *  AtomicLong

### 1.2 原子数组类型 ###

*  AtomicIntegerArray
 *  AtomicLongArray

### 1.3 原子引用类型 ###

*  AtomicReference
 *  AtomicStampedReference

### 1.4 原子属性类型 ###

*  AtomicLongFieldUpdater
 *  AtomicIntegerFieldUpdater

## 2. 非原子类实例 ##

> 测试代码

public class Test { 
    
        static Long totalCount = 0L;
    
        public static void main(String[] args) { 
    
            int j = 0;
            while (j < 100) { 
                totalCount = 0L;
    
                Thread thread1 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            totalCount++;
                        }
                    }
                }, "线程1");
    
    
                Thread thread2 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            totalCount++;
                        }
                    }
                }, "线程1");
    
    
                thread1.start();
                thread2.start();
                try { 
                    thread1.join();
                    thread2.join();
                    System.out.println("当前总数量为：" + totalCount);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                j++;
            }
        }
    }

> 测试结果

当前总数量为：884
    当前总数量为：717
    当前总数量为：563
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：686
    当前总数量为：1000
    ...

> 结论 ：可以看出非原子类在多线程的时候，获得的结果并不是我们想要的

## 3. 原子类实例 ##

> 测试代码

public class Test { 
    
       // static Long totalCount = 0L;
    
       static AtomicInteger totalCount;
    
        public static void main(String[] args) { 
    
            int j = 0;
            while (j < 100) { 
                //原子类，初始值为0
                totalCount =  new AtomicInteger(0);
    
                Thread thread1 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            //totalCount++;
                            totalCount.getAndIncrement();
                        }
                    }
                }, "线程1");
    
    
                Thread thread2 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            //totalCount++;
                            totalCount.getAndIncrement();
                        }
                    }
                }, "线程1");
    
    
                thread1.start();
                thread2.start();
                try { 
                    thread1.join();
                    thread2.join();
                   // System.out.println("当前总数量为：" + totalCount);
                    System.out.println("当前总数量为：" + totalCount.get());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                j++;
            }
        }
    }

> 测试结果

当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000

> 结论 ： AtomicInteger 可以保证在多线程的情况下数据的原子性

## 4. AtomicInteger 常用方法 ##

*  getAndIncrement 先使用再自增1，相当于 n++
 *  getAndDecrement 先使用，再自减1，相当于 n–
 *  decrementAndGet 先减1，再使用，相当于–n
 *  incrementAndGet 先加1，在使用。相当于 ++n
 *  get 获取当前的值

## 4. AtomicInteger 源码分析 ##

> 使用的是unsafe 方法的getAndAddInt 来进行自增的  
> this： 为当前的值  
> valueOffset 地址偏移量，助你找到n在堆中的地址

public final int getAndIncrement() { 
            return unsafe.getAndAddInt(this, valueOffset, 1);
        }

> getIntVolatile 通过volatile直接获取内存中获取到预期值 ：var5  
> var1：当前值  
> var2 ：地址偏移量  
> var5：预期值
> 
> compareAndSwapInt 进行CAS操作  
> var1：当前值  
> var2 ：地址偏移量  
> var4 ：递增间隔  
> var5：预期值  
> 比较 var1 和 var5 是否相同，  
> 相同，代表没有线程更改过，，当前值（var1） = 预期值(var5) + 递增间隔 （var4） 返回true  
> 不相同，代表线程更改过，，当前值（var1） = 预期值(var5) 返回false，再重试

public final int getAndAddInt(Object var1, long var2, int var4) { 
            int var5;
            do { 
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
        }

## 5. ABA问题 ##

> 引发原因

1.  线程1 将var1 =A 读取到线程内存中（栈），
2.  线程2 将var1 改成B ,又改成成A
3.  线程1 在获取预期值var5时， 发现还是A， 符合预期，导致没有返现被更改
4.  其实线程2已经做过更改

## 6. ABA解决 ##

解决思路，对变量增加时间戳或版本号，这样的话，改了的话，时间戳或版本号会更改，在CAS的时候能被发现

> AtomicStampedReference 解决ABA问题  
> getReference 获取预期值  
> getStamp 获取时间戳

> 测试代码

public class ABATest { 
    
        private static AtomicStampedReference<Integer> totalCount;
    
        public static void main(String[] args) { 
    
            int j = 0;
            while (j < 100) { 
                //原子类，初始值为0
                totalCount = new AtomicStampedReference<>(0, 0);
    
                Thread thread1 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            //totalCount++;
                            Integer reference;
                            int stamp;
                            do { 
                                reference = totalCount.getReference();
                                stamp = totalCount.getStamp();
                            } while (!totalCount.compareAndSet(reference, reference + 1, stamp, stamp + 1));
                        }
                    }
                }, "线程1");
    
    
                Thread thread2 = new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        for (int i = 0; i < 500; i++) { 
                            Integer reference;
                            int stamp;
                            do { 
                                reference = totalCount.getReference();
                                stamp = totalCount.getStamp();
                            } while (!totalCount.compareAndSet(reference, reference + 1, stamp, stamp + 1));
    
                        }
                    }
                }, "线程1");
    
    
                thread1.start();
                thread2.start();
                try { 
                    thread1.join();
                    thread2.join();
                    // System.out.println("当前总数量为：" + totalCount);
                    System.out.println("当前总数量为：" + totalCount.getReference());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                j++;
            }
        }
    }

> 测试结果

当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000
    当前总数量为：1000