Java并发-原子类atomic

深碍√TFBOYSˉ_ 2022-04-04 14:56 339阅读 0赞

# 1.非阻塞方式 #

*  原子操作  
    原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何线程的切换。
    
    每个线程都会具有各自的工作内存，Java中所有变量都会存储在主内存中，线程的工作内存都是主内存中变量的副本。线程在各自的工作内存中进行变量的操作后，后再将变量传回主内存，线程之间无法进行直接通信，线程间的变量传递都需要通过主内存来完成。
    
    java内存模型定义了8种原子操作，8种操作如下：  
    lock(锁定)：作用于主内存，它把一个变量标记为一条线程独占状态；  
    read(读取)：作用于主内存，它把变量值从主内存传送到线程的工作内存中，以便随后的load动作使用；  
    load(载入)：作用于工作内存，它把read操作的值放入工作内存中的变量副本中；  
    use(使用)：作用于工作内存，它把工作内存中的值传递给执行引擎，每当虚拟机遇到一个需要使用这个变 量的指令时候，将会执行这个动作；  
    assign(赋值)：作用于工作内存，它把从执行引擎获取的值赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的指令时候，执行该操作；  
    store(存储)：作用于工作内存，它把工作内存中的一个变量传送给主内存中，以备随后的write操作使用；  
    write(写入)：作用于主内存，它把store传送值放到主内存中的变量中。  
    unlock(解锁)：作用于主内存，它将一个处于锁定状态的变量释放出来，释放后的变量才能够被其他线程锁定；
 *  也就是说，我们大部分对于变量的操作都为非原子操作，例如变量的自增，自减等。下面还是一个老例子，变量的自增，这是一个未同步的代码。

public class test1 implements Runnable{ 
    	private  int i=0;
    	public  void  increase() { 
    		i++;
    	}
    	public static void main(String[] args) throws InterruptedException { 
    		Runnable r = new test1();
    		for(int i=0;i<10000;i++) { 
    			Thread t =  new Thread(r);
    			t.start();
    		}
    	}
    	@Override
    	public  void run() { 
    		increase();
    		System.out.println(Thread.currentThread().getName()+"--"+i);
    	}	
    }

若为们需要进行同步，就需要添加synchronized关键字或者Lock进行同步，但是为大材小用。而且使用Lock/synchronized来进行加锁来进行线程的互斥，本质上是通过竞争锁来获取线程的执行机会，问题也会随之而来就是线程的阻塞和唤醒会造成性能问题，这就是一个很好的悲观锁例子，认为只要不进行同步，就会出现问题。

public  synchronized void  increase() { 
    		i++;
    	}

*  So，Java提供的Atomic类，我们只需要新建一个原子跟新变量，将数值设好便好。

public class test1 implements Runnable{ 
    	public static AtomicInteger i = new AtomicInteger(0);
    	public  synchronized void  increase() { 
    		i.incrementAndGet();
    	}
    	public static void main(String[] args) throws InterruptedException { 
    		Runnable r = new test1();
    		for(int i=0;i<10000;i++) { 
    			Thread t =  new Thread(r);
    			t.start();
    		}
    	}
    	@Override
    	public  void run() { 
    		increase();
    		System.out.println(Thread.currentThread().getName()+"--"+i);
    	}	
    }

# 2.底层实现 #

原子类的实现底层其实是为CAS指令，CAS意思为比较并替换，共有三个成员：内存位置（V）、预期原值（A）和新值(B)。CAS指令执行时，会对原本内存地址（V），原值（A）进行保存，当且仅当内存地址上的数值等于原值时，将新值赋值到内存地址上。这是一个乐观锁，失败了也不会进行挂起，而是会去不断的尝试。

但也存在不少问题

1.  尝试时间过长，我们都知道CAS在尝试失败的时候，会不断地进行重复尝试，知道成功，若时间过长，则会给CPU多大的负担。
2.  只能保证一个共享变量的原子操作
3.  ABA问题  
    如果内存地址V初次读取的值是A，并且在准备赋值的时候检查到它的值仍然为A，我们不能一定认为该数值一定未被改变过。如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。Java并发包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。