并发编程-04线程安全性之原子性Atomic包的4种类型详解

package com.artisan.example.atomic;

import java.util.concurrent.atomic.AtomicInteger;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AtomicIntegerDemo {
	
	// 实例化一个初始值为5的AtomicInteger
	private static AtomicInteger value = new AtomicInteger(5);
	
	public static void main(String[] args) {
		// 以原子方式将输入的数值与value 相加，并返回结果 
		log.info("value的值：{}" ,value.addAndGet(3));
		
		// 获取value的值
		log.info("value的值：{}",value.get());

		// 如果输入的数值等于预期值，则以原子方式将该值设置为输入的值
		log.info("执行结果：{}" ,value.compareAndSet(8, 11)); // 因为经过了addAndGet，操作之前value的值为8，这里会将value更新成11，返回true
		log.info("执行结果：{}" ,value.compareAndSet(5, 11)); // 因为经过了addAndGet，操作之前value的值为8，并不等于5，因此不会更新为11，返回false
		
		
		log.info("value的值：{}" ,value.get());
		
		
		log.info("value 增长前的值：{}",value.getAndIncrement());
		log.info("value的值：{}" ,value.get());
		
		log.info("value 增长后的值：{}",value.incrementAndGet());
		log.info("value的值：{}" ,value.get());
		
		
		//  最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值
		value.lazySet(99);
		log.info("lazyset value: {}",value.get());
		
	}
}

package com.artisan.example.atomic;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AtomicBooleanDemo {
	
	//总请求数
	private static int clientTotal = 5000;
	// 同一时间允许执行的线程数
	private static int threadTotal = 200;
	
	// 标识  ，使用原子包中的AtomicBoolean  初始化为false
	private static AtomicBoolean atomicBooleanFlag = new AtomicBoolean(false);
	
	public static void main(String[] args) throws Exception {
		
		// 线程池
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		// 信号量 同一时间允许threadTotal个请求同时执行 即初始化threadTotal个信号量
		Semaphore semaphore = new Semaphore(threadTotal);
		
		//定义clientTotal个线程需要执行完，主线程才能继续执行
		CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
		
		// 循环
		for (int i = 0; i < clientTotal; i++) {
			executorService.execute(() ->{
				try {
					semaphore.acquire();
					doSomething();
					semaphore.release();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 减一
				countDownLatch.countDown();
			});
		}
		
		// 当全部线程都调用了countDown方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。
		countDownLatch.await();
		// 关闭线程池
		executorService.shutdown();
		
		log.info("flag:{}" ,atomicBooleanFlag.get());
		
	}

	
	private static void doSomething() {
		// 如果flag为flase就将其设置为true
		if (atomicBooleanFlag.compareAndSet(false, true)) {
			log.info("doSomething executed");
		}
	}

}

package com.artisan.example.atomic;

import java.util.concurrent.atomic.AtomicIntegerArray;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AtomicIntegerArrayDemo {

	private static int[] array = new int[] { 11, 22 };

	private static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(array);

	public static void main(String[] args) {

		// 给array[0]的值增加33 ，然后返回增长后的值 44
		log.info("atomicIntegerArray addAndGet ：{}", atomicIntegerArray.addAndGet(0, 33)); // 44
		// 输出 atomicIntegerArray中
		log.info("atomicIntegerArray get ：{}", atomicIntegerArray.get(0)); // 44

		// 数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组 复制一份，
		// 所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组
		log.info("array[0]的值： {}", array[0]); // 11

		// 先get 然后再add ,返回add之前的值
		log.info("atomicIntegerArray getAndAdd ：{}", atomicIntegerArray.getAndAdd(0, 33)); // 44
		log.info("atomicIntegerArray .get(0) ：{}", atomicIntegerArray.get(0)); // 44+33
		log.info("array[0]的值： {}", array[0]); // 11

		// 先get ,然后再set,返回set之前的数据
		log.info("atomicIntegerArray getAndSet ：{}", atomicIntegerArray.getAndSet(0, 33));// 77
		log.info("atomicIntegerArray get(0) ：{}", atomicIntegerArray.get(0)); // 33
		log.info("array[0] ：{}", array[0]); // 11 

	}

}

package com.artisan.example.atomic;

import java.util.concurrent.atomic.AtomicReference;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AtomicReferenceDemo {

	private static AtomicReference<Artisan> atomicReferenceArtisan = new AtomicReference<Artisan>();

	public static void main(String[] args) {

		Artisan expectedArtisan = new Artisan();
		expectedArtisan.setName("小工匠");
		expectedArtisan.setAge(20);

		// 将expectedArtisan设置到atomicReferenceArtisan
		atomicReferenceArtisan.set(expectedArtisan);

		Artisan updateArtisan = new Artisan();
		updateArtisan.setName("小工匠Update");
		updateArtisan.setAge(99);

		// compareAndSet方法进行原子更新操作,如果是expectedArtisan，则更新为updateArtisan

		boolean mark2 = atomicReferenceArtisan.compareAndSet(new Artisan(), updateArtisan);
		log.info("更新是否成功：{}", mark2);// false

		boolean mark = atomicReferenceArtisan.compareAndSet(expectedArtisan, updateArtisan);
		log.info("更新是否成功：{}", mark); // true

		log.info("atomicReferenceArtisan name:{}", atomicReferenceArtisan.get().getName());
		log.info("atomicReferenceArtisan age：{}", atomicReferenceArtisan.get().getAge());

	}

}

package com.artisan.example.atomic;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AtomicIntegerFieldUpdaterDemo {

	// 创建原子更新器，并设置需要更新的对象类和对象的属性
	private static AtomicIntegerFieldUpdater<Artisan2> atomicIntegerFieldUpdaterArtisan = AtomicIntegerFieldUpdater
			.newUpdater(Artisan2.class, "age");

	public static void main(String[] args) {
		Artisan2 artisan = new Artisan2();
		artisan.setAge(20);
		
		log.info("目前atomicIntegerFieldUpdaterArtisan中age的值为:{}",atomicIntegerFieldUpdaterArtisan.get(artisan));
		
		if (atomicIntegerFieldUpdaterArtisan.compareAndSet(artisan, 20, 99)) {
			log.info("artisan的age属性的值期望为20，则将20更新为99，更新成功");
		}
		
		// 获取artisan更新后的age的值
		log.info("目前atomicIntegerFieldUpdaterArtisan中age的值为:{}",atomicIntegerFieldUpdaterArtisan.get(artisan));
		
		
		if (atomicIntegerFieldUpdaterArtisan.compareAndSet(artisan, 20, 99)) {
			log.info("artisan的age属性的值期望为20，则将20更新为99，更新成功");
		}else {
			log.info("artisan的age属性的值期望为20，则将20更新为99，更新失败. 目前age的值为：{}",atomicIntegerFieldUpdaterArtisan.get(artisan));
		}
		
		
	}
}

package com.artisan.example.atomic;

import lombok.Data;

@Data
public class Artisan2 {
	String name;
	public volatile int age;
}