005 volatile不能保证原子性之i++操作

专注_每天进步一点点

已于 2022-03-19 05:16:14 修改

阅读量3.4k

点赞数

分类专栏： 04Java多线程高并发文章标签： java 开发语言 volatile 高并发

于 2022-03-09 11:15:55 首次发布

本文链接：https://blog.csdn.net/qq_32649581/article/details/123357258

版权

04Java多线程高并发专栏收录该内容

91 篇文章 4 订阅

订阅专栏

本文探讨了volatile关键字在多线程环境下对于变量i++操作的非原子性问题，导致结果不准确。解决方案包括使用synchronized和AtomicInteger，以及JDK8的LongAdder，它们提供了原子性保证。volatile仅保证可见性，不保证操作的原子性，因此在高并发场景下需要额外的同步措施。

摘要由CSDN通过智能技术生成

1、多线程对volatile修饰的变量做 count++ 操作，没有保证原子性

下面启动了1000个线程对volatile修饰的变量进行i++操作，我们可能会想每一个线程都+1,当1000个线程都执行完+1操作之后结果应该是1000，但是执行代码试试，结果可能不是1000。这说明volatile不是原子性的。


public class Counter {
	public static volatile int count = 0;

	public static void inc() {
		try {
			// sleep 1 毫秒让效果明显
			Thread.currentThread().sleep(1);
		} catch (Exception e) {
			e.printStackTrace();
		}
		count++;
	}

	public static void main(String[] args) {

		// 同时启动1000个线程，去进行i++计算，看看实际结果
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Counter.inc();
				}
			}).start();
		}

		// 保证前面的线程都执行完
		while (Thread.activeCount() > 1) {
			Thread.yield();
		}

		// 这里每次运行的值都有可能不同,可能不是1000
		System.out.println("运行结果:Counter.count=" + Counter.count);
	}
}

2、多线程对volatile修饰的变量做 count++ 操作，没有保证原子性。解决方案一

去掉volatile关键字，在 count++ 的方法上加 synchronized 关键字；或者不去掉volatile关键字，在 count++ 的方法上加 synchronized 关键字

public class Counter {
	public static int count = 0;

	public synchronized static void inc() {
		try {
			// sleep 1 毫秒让效果明显
			Thread.currentThread().sleep(1);
		} catch (Exception e) {
			e.printStackTrace();
		}
		count++;
	}

	public static void main(String[] args) {

		// 同时启动1000个线程，去进行i++计算，看看实际结果
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Counter.inc();
				}
			}).start();
		}

		// 保证前面的线程都执行完
		while (Thread.activeCount() > 1) {
			Thread.yield();
		}

		// 这里每次运行的值都相同,一定是1000
		System.out.println("运行结果:Counter.count=" + Counter.count);
	}
}

synchronized 是重量级锁，开销很大。

3、多线程对volatile修饰的变量做 count++ 操作，没有保证原子性。解决方案二

使用AtomicInteger里面的getAndIncrement（）方法


import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
	public static AtomicInteger count = new AtomicInteger(0);

	public static void inc() {
		try {
			// sleep 1 毫秒让效果明显
			Thread.currentThread().sleep(1);
		} catch (Exception e) {
			e.printStackTrace();
		}
		count.getAndIncrement();
	}

	public static void main(String[] args) {

		// 同时启动1000个线程，去进行i++计算，看看实际结果
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Counter.inc();
				}
			}).start();
		}

		// 保证前面的线程都执行完
		while (Thread.activeCount() > 1) {
			Thread.yield();
		}

		// 这里每次运行的值都相同,一定是1000
		System.out.println("运行结果:Counter.count=" + Counter.count);
	}
}

4、多线程对volatile修饰的变量做 count++ 操作，没有保证原子性。假如你使用的是JDK8 ，可以考虑解决方案三，LongAdder。

LongAdder，（高竞争环境下（比如1000个线程竞争的情况），LongAdder 比 AtomicLong 的性能高，至于为什么高呢？去看看源码看看百度）


import java.util.concurrent.atomic.LongAdder;

public class Counter {
	public static LongAdder count = new LongAdder();

	public static void inc() {
		try {
			// sleep 1 毫秒让效果明显
			Thread.currentThread().sleep(1);
		} catch (Exception e) {
			e.printStackTrace();
		}
		count.increment();
	}

	public static void main(String[] args) {

		// 同时启动1000个线程，去进行i++计算，看看实际结果
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Counter.inc();
				}
			}).start();
		}

		// 保证前面的线程都执行完
		while (Thread.activeCount() > 1) {
			Thread.yield();
		}

		// 这里每次运行的值都相同,一定是1000
		System.out.println("运行结果:Counter.count=" + Counter.count);
	}
}