volatile 内存可见性   多个线程操作共享数据时，可以保存内存中的数据可见
 *             相较于synchronized是一种较为轻量级的同步策略

 * 注意：
 * 1.volatile不具备互斥性
 * 2.volatile不能保证原子性
 * jvm会给每一个线程分配独立的内存

package thread;
/**
 * volatile 内存可见性   多个线程操作共享数据时，可以保存内存中的数据可见
 * 			相较于synchronized是一种较为轻量级的同步策略
 * 注意：
 * 1.volatile不具备互斥性
 * 2.volatile不能保证原子性
 * jvm会给每一个线程分配独立的内存
 * @author wangqiangac
 * @verion NCC-1.0
 * @since 2021-10-13 16:11:21
 */
public class TestVolatile {
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		new Thread(td).start();
		while(true) {
//			synchronized (td) {
				if(td.isFlag()) {
					System.out.println("-------------");
					break;
//				}
			}
		}
	}
}


class ThreadDemo implements Runnable{
	private volatile boolean flag = false;
	
	@Override
	public void run() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		flag = true;
		System.out.println("flag="+isFlag());
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	
}

* i++原子性   有读改写
 * 
 * 原子变量 java.util.concurrent.atomic 提供了常用的原子变量
 *     1. volatile 保证内存可见性
 *     2. CAS (Compare-And-Swap)算法保证数据的原子性   CAS算法是硬件对于并发操作共享数据的支持
 *         CAS包含了3个操作数
 *         内存值V
 *         预估值A
 *         更新值B
 *         当且仅当V==A时 V=B 否则什么都不做

package thread;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * i++原子性   有读改写
 * 
 * 原子变量 java.util.concurrent.atomic 提供了常用的原子变量
 * 	1. volatile 保证内存可见性
 * 	2. CAS (Compare-And-Swap)算法保证数据的原子性   CAS算法是硬件对于并发操作共享数据的支持
 * 		CAS包含了3个操作数
 * 		内存值V
 * 		预估值A
 * 		更新值B
 * 		当且仅当V==A时 V=B 否则什么都不做
 * @author wangqiangac
 * @verion NCC-1.0
 * @since 2021-10-14 14:03:17
 */
public class TestAutomicDemo {

	public static void main(String[] args) {
		
		AutomicDemo ad = new AutomicDemo();
		for (int i = 0; i < 10; i++) {
			new Thread(ad).start();
		}
	}
}

class AutomicDemo implements Runnable{
	
	private AtomicInteger serialNum = new AtomicInteger(0);
	@Override
	public void run() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(getSerialNum());
	}
	public int getSerialNum() {
		return serialNum.getAndIncrement();//后++
	}
}

模拟CAS

package thread;

/**
 * 模拟CAS
 * @author wangqiangac
 * @verion NCC-1.0
 * @since 2021-10-14 14:38:32
 */
public class TestCompareAndSwap {

	public static void main(String[] args) {
		final CompareAndSwap cas = new CompareAndSwap();
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					int expecteValue = cas.get();
//					System.out.println("更新前获取期望值："+expecteValue);
					boolean ss= cas.compareAndSet(expecteValue, (int)(Math.random()*101));
					System.out.println(ss);
				}
			}).start();
		}
	}
}

class CompareAndSwap{
	private int value;
	
	public synchronized int get() {
		return this.value;
	}
	
	public synchronized int compareAndSwap(int expecteValue,int newValue) {
		int oldvalue = value;
		if(expecteValue==oldvalue) {
			this.value = newValue;
			
//			System.out.println("value被更新："+newValue);
		}
		return oldvalue;
	}
	
	public synchronized boolean compareAndSet(int expecteValue,int newValue) {
		return expecteValue == compareAndSwap(expecteValue,newValue);
	}
}