锁（一）乐观锁

乐观锁

1.锁是为了解决数据脏读，不一致的问题。
2.悲观锁synchronized，这种线程一旦得到锁，其他线程就会挂起，进入阻塞状态。(遇到困难，止步不前，悲观)
3.乐观锁CAS，是不加锁的，而是去通过判断有没有冲突，再去完成某个操作，如果有冲突，会一直去重试，直到完成为止。（屡败屡战，乐观）
4.从思想上来说，Synchronized属于悲观锁，悲观地认为程序中的并发情况严重，所以严防死守。CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新

CAS

CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。
CAS机制是有3个基本操作值，内存值A，旧值A’，新值B。当进行数据更新时，先进行内存值A与旧值A’的比较，如果值相等，则将内存值更新为新值B；如果两值不相等，则需要取到内存值A，以内存值A为起始值重新进行线程计算，从而得到另外一个新值，再次重复上述动作。直到更新成功。

代码块

public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //每个线程让count自增100次
                    for (int i = 0; i < 100; i++) {
                        count++;
                    }
                }
            }).start();
        }
        try{
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(count);
    }

如上述demo，按照理想逻辑，每个线程自增至100，两个线程即等于200；但是结果不一定是200，有可能是200以内。当线程1自增至20时，线程2是可以访问到count的，此时取到了count，那么线程2就是从20开始自增至100，最终结果线程1，100次，线程2，80次，count=180。为规避此类问题发生，我们可以加锁synchronized，变成了一个原子操作，实现了线程安全。

for (int i = 0; i < 100; i++) {
                        synchronized (ThreadCas.class){
                            count++;
                        }
                    }

虽然实现了线程安全，但是当高并发时，线程之间会争夺资源，无法得到锁，进入阻塞BLOCKED状态，获取到锁后，恢复RUNNABLE。线程之间的状态转换造成性能的降低。So，使用原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如AtomicBoolean，AtomicInteger，AtomicLong。它们分别用于Boolean，Integer，Long类型的原子性操作。

private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //每个线程让count自增100次
                    for (int i = 0; i < 100; i++) {
                        count.incrementAndGet();
                    }
                }
            }).start();
        }

        try{
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(count);
    }

CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。