并发-共享模型-无锁

共享模型-无锁

CAS和volatile

private AtomicInteger balance; // AtomicInteger原子整数

while(true){
    int prev = balance.get();
    int next = prev - amount;
    if(balance.compareAndSet(prev,next)){
        break;
    }
}

compareAndSet简称CAS，它内部是原子操作，可以保证原子性

CAS的底层是lock cmpxchg指令（X86架构），在单核和多核CPU下都能够保证【比较-交换】的原子性

获取变量时，为了保证该变量的可见性，需要用volatile修饰

CAS必须借助volatile才能读取到共享变量的最新值来实现【比较并交换】的效果

无锁情况下效率更高，即使重试失败，线程始终在高速运行没有停歇，而synchronized会让线程在没有获得锁的时候发生上下文切换，进入阻塞 。

但无锁情况下，因为线程要保持运行，需要额外CPU的支持，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还会导致上下文切换

CAS的特点

结合CAS和volatile可以实现无锁并发，适用于线程数少，多核CPU的场景

• CAS是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改变量，就算改了也没关系，再重试一下就行
• synchronized是基于悲观锁的思想：最悲观的估计，防着其他线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁才有机会
• CAS体现的是无锁并发、无阻塞并发
  • 因为没有使用synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
  • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

原子整数

JUC并发包提供了：AtomicBoolean、AtomicInteger、AtomicLong

以AtomicInteger为例：

AtomicInteger i = new AtomicInteger(0); i=0 原子的

System.out.println(i.incrementAndGet());// 自增并获取值 ++i 打印1 i=1
System.out.println(i.getAndIncrement());// 获取并自增值 i++ 打印1 i=2

System.out.println(i.getAndAdd(5)); // 获取并增加 打印2 i=7
System.out.println(i.addAndGet(5)); // 增加并获取 打印12 i=12

//                              读取值  设置值
System.out.println(i.updateAndGet(i -> i*10)); // 改变并获取 12*10 打印120 i=120

原子引用

AtomicReference、AtomicMarkReference、AtomicStampedReference

原子数组

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

// supplier 提供者  无中生有  ()->无结果
// function 函数  一个参数一个结果  (参数)->结果 ， BiFunction (参数1，参数2)->结果
// consumer 消费者  一个参数没有结果  (参数)->无结果  ， BiConsumer (参数1，参数2)->无结果
private static <T> void demo(
	Supplier<T> arraySupplier,
    Function<T,Integer> lengthFun,
    BiConsumer<T,Integer> putConsumer,
    Consumer<T> printConsumer) {
    
    List<Thread> ts = new ArrayList<>();
    T array = arraySupplier.get();
    int length = lengthFun.apply(array);
    for(i = 0; i < length; i++){
        // 每个线程对数组进行10000次操作
        ts.add(new Thread(()->{
            for(j = 0; j < 10000; j++){
                putConsumer.accept(array,j%length);
            }
        }));
    }
    
    ts.forEach(t -> t.start()); // 启动所有线程
 	ts.forEach(t -> {
 		try {
 			t.join();
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
 	}); // 等所有线程结束
 	printConsumer.accept(array);
}

public staic void main(String[] args){
    demo(
        ()->new AtomicIntegerArray(10),
        (array)->array.length(),
        (array,index)->array[index]++,
        (array)->System.out.println(array)
    );
}

字段更新器

AtomicReferenceFieldUpdater 、AtomicIntegerFieldUpdater、 AtomicLongFieldUpdater

利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现 异常

AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdete.newUpdete(Student.class,String.class,"name")
//                                   类名           字段类型      字段名
Student stu = new Student();
updeter.compareAndSet(stu,null,"张三")

原子累加器

LongAdder、LongAccumulator

性能比AtomicInteger和AtomicLong高很多

LongAdder adder = new LongAdder();
adder.increment();

性能提升的原因：在竞争时，设置多个累加单元，Thread-0累加Cell[0]，而Thread-1累加Cell[1]…最后将结果汇总。这样在累加时操作的不同Cell变量，减少了CAS重试失败，从而提升性能

Unsafe

Unsafe对象提供了非常底层的，操作内存、线程的方法，Unsafe对象不能直接调用，只能通过反射获得

Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");// 获得域对象theUnsafe
// 获得成员变量的值，theUnsafe是静态的从属于类 所以传入null
Unsafe unsafe = (Unsafe) theUnsafe.get(null);

// 获得域的偏移地址
long idOffset = unsafe.objectFieldOffset(Student.class.getDeclaredField("id"));
long nameOffset = unsafe.objectFieldOffset(Student.class.getDeclaredField("name"));

Student s = new Student();
unsafe.compareAndSwapInt(s,idOffset,0,1);
unsafe.compareAndSwapObject(s,nameOffset,null,"张三");

---