CAS操做

CAS操做：

Compare and Swap，比较并操做，CPU指令，在大多数处理器架构，包括IA3二、Space中采用的都是CAS指令，CAS的语义是“我认为V的值应该为A，若是是，那么将V的值更新为B，不然不修改并告诉V的值实际为多少”，CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知此次竞争中失败，并能够再次尝试。CAS有3个操做数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改成B，不然什么都不作。

 

悲观锁和乐观锁

独占锁是一种悲观锁，synchronized就是一种独占锁，它假设最坏的状况，而且只有在确保其它线程不会形成干扰的状况下执行，会致使其它全部须要锁的线程挂起，等待持有锁的线程释放锁。而另外一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操做，若是由于冲突失败就重试，直到成功为止。

 

简单来说就是，当我所认为的A与实际上内存的V相同的时候，就把新的值B给V，不然就失败重来。

 

这里粘贴一个，模拟CAS实现的计数器：

public class CASCount implements Runnable {
    
    private SimilatedCAS counter = new SimilatedCAS();  

    @Override
    public void run() {
         for (int i = 0; i < 10000; i++) {  
                System.out.println(this.increment());  
         }  
    }
    
    public int increment() {
        int oldValue = counter.getValue();
        int newValue = oldValue + 1;
        
        while (!counter.compareAndSwap(oldValue, newValue)) { //若是CAS失败,就去拿新值继续执行CAS
              oldValue = counter.getValue();  
              newValue = oldValue + 1;  
        }
        
        return newValue;
    }
    
    public static void main(String[] args) {  
        Runnable run = new CASCount();  
  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
    }  
}
class SimilatedCAS {
    private int value;
    
    public int getValue() {
        return value;
    }
    
    // 这里只能用synchronized了,毕竟没法调用操做系统的CAS  
    public synchronized boolean compareAndSwap(int expectedValue, int newValue) {  
        if (value == expectedValue) {  
            value = newValue;  
            return true;  
        }  
        return false;  
    }  
}