线程安全性-原子性-Atomic包-1

港控/mmm° 2022-05-26 05:29 300阅读 0赞

## 一.什么是线程安全性: ##

定义:当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

## 二.线程安全性表现在三方面: ##

1.  **原子性**:提供互斥访问,在同一时刻只能有一个线程对他访问
2.  **可见性**:一个线程对内存的修改可以及时的被其他线程观察到
3.  **有序性**:一个线程观察其他线程中的指令顺序,由于指令重排序的存在,观察结果一般杂乱无序

## 三:原子性–Atomic包 ##

> Atomic包都是通过CAS理论完成线程的原子性  
> AtomicInteger类 ,会出现循环

public class AtomicExple1 { 
        // 请求总数
        public static int clientTotal = 5000;
    
        // 同时并发执行的线程数
        public static int threadTotal = 200;
    
        //原子特性atomic
        public static AtomicInteger count = new AtomicInteger(0);
    
        public static void main(String[] args) throws Exception { 
            ExecutorService executorService = Executors.newCachedThreadPool();
            final Semaphore semaphore = new Semaphore(threadTotal);
            final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
            for (int i = 0; i < clientTotal ; i++) { 
                executorService.execute(() -> { 
                    try { 
                        semaphore.acquire();
                        add();
                        semaphore.release();
                    } catch (Exception e) { 
                        log.error("exception", e);
                    }
                    countDownLatch.countDown();
                });
            }
            countDownLatch.await();
            executorService.shutdown();
            log.info("count:{}", count.get());
        }
    
        private static void add() { 
            //这是表现线程安全,及原子性
            count.incrementAndGet();//先增后取值
            // count.getAndIncrement();
        }
    }

备注:为什么表现出原子性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70 1]

源码分析:

//var1是count的对象,var2是当前对象在内存的偏移量,var4 就是1(要加上的值)
    	public final int getAndAddInt(Object var1, long var2, int var4) { 
            int var5;
            do { 
            	//获取对象内存地址偏移量上的数值var5
                var5 = this.getIntVolatile(var1, var2);
                //如果现在还是var5,设置为 var5 + var4,否则返回false,继续循环再次重试.
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
        }

## 四.AtomicLong,LongAdder这两个类,线程安全 ##

大量线程并发更新一个原子类的时候，天然的一个问题就是自旋,分段迁移，某一个线程如果对一个Cell更新的时候，发现说出现了很难更新他的值，出现了多次自旋的一个问题，如果他CAS失败了，自动迁移段，他会去尝试更新别的Cell的值，这样的话就可以让一个线程不会盲目的等待一个cell的值.  
LongAdder原理图:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70_pic_center]

## 五.AtomicReference,AtomicReferenceFieldUpdater类: ##

*  AtomicReference

private static AtomicReference<Integer> count = new AtomicReference<>(0);
    
      public static  void main(String[] args){ 
        count.compareAndSet(0, 2);//count等于0时候复制给2
        count.compareAndSet(0, 1);
        count.compareAndSet(1, 3);
        count.compareAndSet(2, 4);
        count.compareAndSet(3, 5);
        log.info("count {}", count.get());//最后输出为4
      }

*  AtomicReferenceFieldUpdater

public class CountExample5 { 
      /** * param:是要更新的类型 */
      private static AtomicIntegerFieldUpdater<CountExample5> updater =
              AtomicIntegerFieldUpdater.newUpdater(CountExample5.class, "count");//要更新的字段
    
      @Getter
      private  volatile int count = 100;//要更新的字段,必须有volatile修饰
      //更新的类型
      private static CountExample5 countExample5 = new CountExample5();
    
      public static  void main(String[] args){ 
        if(updater.compareAndSet(countExample5, 100, 120)){ 
          log.info("update success 1 {}", countExample5.getCount());//120;
        }
        if(updater.compareAndSet(countExample5, 100, 120)){ 
          log.info("update success 2 {}", countExample5.getCount());
        }else { 
          log.error("update fail {}", countExample5.getCount());//120
        }
      }
    }

## 六:AtomicStampReference:解决了CAS理论的ABA问题; ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70]: /images/20220526/cde77de92cec42d3b8d309087d8d7e7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70 1]: /images/20220526/494e681629de43c9b424267d82270ccc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N3bF8wNTE0_size_16_color_FFFFFF_t_70_pic_center]: /images/20220526/ec67fccb2722481493749248d8673421.png