高性能编程之线程安全问题（原子性）

interrupt()详解：

这个方法并不能直接去中断一个线程，执行这个方法之后和线程状态没有什么关系，只是改变了一个中断状态。由默认的false —> true 。
如何使用一个interrupt()去中断一个线程？
判断条件为当前线程的interrupt状态（isInterrupt()）中断状态。
当线程处于waiting \ TimedWaiting ,执行interrupt（）会从waiting \ TimedWaiting中退出，抛出一个异常 （java.lang.InterruptException）并且这个isInterrupted标志会擦除，又改回原来的false.其实是因为抛出了异常没有处理，中断了线程。
原子性出现的场景：
1、在判断了某一个状态的时候，下一时刻这个状态失效了。

2.加载了一个值，这个值失效了。

原子性的核心特征： 将整个操作视为一个整体，资源在该次操作中要保持一致。

解决原子性：

CAS

硬件级别，处理器提供了基本内存操作的原子性保证。

CAS操作需要俩个数值，一个旧值A 和一个新值B，在操作期间先对旧值进行比较，若没有发生变化，才交换为新值。发生了变化就不会交换。
在java中提供了Unsafe类 ，比如compareAndSwaoInt()等许多方法，实现了CAS操作。
手写CAS保证i++ 原子性。

package com.stx;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class AtomicTest {
    volatile int i = 0 ; //必須要volatile修飾 保證可見性
    private static Unsafe unsafe = null ;
    private static long offset;
    
    static{

        try {
            Field field_unsafe = Unsafe.class.getDeclaredField("theUnsafe");
            field_unsafe.setAccessible(true);
                //提供反射获取unsafe对象
                 unsafe = (Unsafe) field_unsafe.get(null);
                //获取i
                Field filed_i= AtomicTest.class.getDeclaredField("i");
                //获取i字段的 偏移量
                offset = unsafe.objectFieldOffset(filed_i);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
    
    public void  add(){
        while (true){
            //unsafe 通过偏移量 来 获取当前值
            int currentI = unsafe.getIntVolatile(this, offset);
            if(unsafe.compareAndSwapInt(this,offset,currentI,currentI+1)){
                break;
            }
        }
    }
    
}

package com.stx;

import org.junit.Test;

class test01 {


    public static void main(String[] args) throws InterruptedException {
        final AtomicTest atomicTest = new AtomicTest();

        for (int j = 0; j < 10; j++) {
            new Thread(new Runnable() {
                public void run() {
                    for (int k = 0; k < 10000; k++) {
                        atomicTest.add();
                    }
                    System.out.println("執行中");
                }
            }).start();

        }
        Thread.sleep(6000);
        System.out.println(atomicTest.i);
    }
}

结果：

CAS的三个问题：
1、循环+cas 自旋问题让所有的线程都处于高频运行，争抢CPU的执行时间，如果长时间操作不成功，会带来很大的CPU资源损耗。
2.仅可以支持对单个变量的操作，不能用于多个变量来实现原子操作。
3.ABA问题（比较的不全面）