多线程与高并发6

1、CAS

无锁优化。又叫自旋，非重量级锁，不会发生死锁。

package com.example.demo.gc18;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class T01_AtomicInteger {
    //int count1 = 0;
    AtomicInteger count = new AtomicInteger(0);
    void m(){
        for (int i=0;i<10000;i++){
            count.incrementAndGet(); //count1++
        }

    }

    public static void main(String[] args) {
        T01_AtomicInteger t = new T01_AtomicInteger();
        List<Thread> thread = new ArrayList<>();
        for (int i=0;i<10;i++){
            thread.add(new Thread(t::m,"thread-"+i));
        }
        thread.forEach((o) -> o.start());
        thread.forEach((o) -> {
            try{
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
        System.out.println(t.count);
    }
}

Atomic类原子类。凡是Atomic开头的类都是通过CAS操作来保证线程安全。
这时候count++是线程安全的。

  count.incrementAndGet(); 等同于count++；

源码如下：

   /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

  public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

compareAndSwapInt操作是compare and swap 又称CAS
中文意思是比较并设定。
当我原本想改变某一个值0，想将它变为1.但是我想做到线程安全。这时候只能加synchronized锁。不然就不安全。但是我们可以用另外一种方式保证线程安全。
cas就是以下操作

cas（V,Expected,NewValue）

V:要修改的值
Expected:预期值
NewValue：要设定的新值

意思是当前线程改这个值的时候期望是0 ，你不能是1.如果是1，说明其他线程改了。则不是我的期望值。我当前线程改不了。是1我才改。我经过cas机制再重新自旋试一下。下一次我期望值是1，这时候如果其他线程没改。则我正好改。改成2.如此自旋循环查找到最新值。
####1、别的线程没改。符合预期值。我改。自增1
####2、别的线程改了。不符合预期值。自旋。期望值增1.继续看是否符合预期值符合回到第一步。不符合继续走第二步。

2、cas缺陷：ABA问题

我们知道cas是别的线程没有更改自己线程的期望值。是可以自增1的。但是如果有其他线程搞事情把1变成2又变成1。会不会影响cas操作。这就是aba问题

####ABA问题解决方式
校验值+版本号一起校验。无论你怎么改值。版本号都是自增1就能解决ABA问题

3、Atomic类和线程同步新机制

以前我们a++的时候必须加锁。多线程访问下。现在有了AtomicInteger
内部实现cas直接使用count.incrementAndGet()就可以实现a++。

####对于多线程处理一个Long类型数递增有几种方法？
1、递增加重量级锁synchronized
2、使用AtomicLong类
3、LongAdder

在很多测试中高并发中。效率大小比较：LongAdder>AtomicLong>synchronized

package com.example.demo.gc18;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

public class T02_AtomicvsLongAdder {
    static long count2 = 0L;
    static AtomicLong count1 = new AtomicLong();
    static LongAdder count3 = new LongAdder();

    public static void main(String[] args) throws InterruptedException {
        // 2、模拟AtomicLong多线程并发
        Thread[]threads = new Thread[1000];
        for (int i=0;i<threads.length;i++){
            threads[i] =
                    new Thread(() -> {
                       for (int k=0;k<100000;k++){
                           count1.incrementAndGet();
                       }
                    });
        }
        long start = System.currentTimeMillis();
        for (Thread t:threads) t.start();
        for (Thread t:threads) t.join();
        long end = System.currentTimeMillis();
        System.out.println("Atomic:"+count1.get()+"time"+(end-start));
        System.out.println("========================================");
        // 1、模拟synchronized高并发
        Object lock = new Object();
        for(int i=0;i<threads.length;i++){
            threads[i]=
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            for (int k=0;k<100000;k++){
                                synchronized (lock){
                                    count2++;
                                }
                            }
                        }
                    });
        }
        start = System.currentTimeMillis();
        for (Thread t:threads) t.start();
        for (Thread t:threads) t.join();
        end = System.currentTimeMillis();
        System.out.println("sync:"+count2+"time"+(end-start));
        System.out.println("========================================");
        // 3、LongAdder
        for(int i=0;i<threads.length;i++){
            threads[i]=
                    new Thread(() ->{
                       for(int k=0;k<100000;k++){
                           count3.increment();
                       }
                    });
        }
        start = System.currentTimeMillis();
        for (Thread t:threads) t.start();
        for (Thread t:threads) t.join();
        end = System.currentTimeMillis();
        System.out.println("LongAdder:"+count3.longValue()+"time"+(end-start));
    }

    static void microSleep(int m){
        try {
            TimeUnit.MICROSECONDS.sleep(m);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}