Java8中CAS的增强

几天前，我偶然地将之前写的用来测试AtomicInteger和synchronized的自增性能的代码跑了一下，意外地发现AtomicInteger的性能比synchronized更好了，经过一番原因查找，有了如下发现：

在jdk1.7中，AtomicInteger的getAndIncrement是这样的：

    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

而在jdk1.8中，是这样的：

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

可以看出，在jdk1.8中，直接使用了Unsafe的getAndAddInt方法，而在jdk1.7的Unsafe中，没有此方法。（PS:为了找出原因，我反编译了Unsafe，发现CAS的失败重试就是在getAndAddInt方法里完成的，我用反射获取到Unsafe实例，编写了跟getAndAddInt相同的代码，但测试结果却跟jdk1.7的getAndIncrement一样慢，不知道Unsafe里面究竟玩了什么黑魔法，还请高人不吝指点）（补充：文章末尾已有推论）

通过查看AtomicInteger的源码可以发现，受影响的还有getAndAdd、addAndGet等大部分方法。

有了这次对CAS的增强，我们又多了一个使用非阻塞算法的理由。

最后给出测试代码，需要注意的是，此测试方法简单粗暴，compareAndSet的性能不如synchronized，并不能简单地说synchronized就更好，两者的使用方式是存在差异的，而且在实际使用中，还有业务处理，不可能有如此高的竞争强度，此对比仅作为一个参考，该测试能够证明的是，AtomicInteger.getAndIncrement的性能有了大幅提升。

package performance;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;

public class AtomicTest {
	//测试规模，调用一次getAndIncreaseX视作提供一次业务服务，记录提供TEST_SIZE次服务的耗时
	private static final int TEST_SIZE = 100000000;
	//客户线程数
	private static final int THREAD_COUNT = 10;
	//使用CountDownLatch让各线程同时开始
	private CountDownLatch cdl = new CountDownLatch(THREAD_COUNT + 1);

	private int n = 0;
	private AtomicInteger ai = new AtomicInteger(0);
	private long startTime;

	public void init() {
		startTime = System.nanoTime();
	}

	/**
	 * 使用AtomicInteger.getAndIncrement，测试结果为1.8比1.7有明显性能提升
	 * @return
	 */
	private final int getAndIncreaseA() {
		int result = ai.getAndIncrement();
		if (result == TEST_SIZE) {
			System.out.println(System.nanoTime() - startTime);
			System.exit(0);
		}
		return result;
	}

	/**
	 * 使用synchronized来完成同步，测试结果为1.7和1.8几乎无性能差别
	 * @return
	 */
	private final int getAndIncreaseB() {
		int result;
		synchronized (this) {
			result = n++;
		}
		if (result == TEST_SIZE) {
			System.out.println(System.nanoTime() - startTime);
			System.exit(0);
		}
		return result;
	}

	/**
	 * 使用AtomicInteger.compareAndSet在java代码层面做失败重试（与1.7的AtomicInteger.getAndIncrement的实现类似），
	 * 测试结果为1.7和1.8几乎无性能差别
	 * @return
	 */
	private final int getAndIncreaseC() {
		int result;
		do {
			result = ai.get();
		} while (!ai.compareAndSet(result, result + 1));
		if (result == TEST_SIZE) {
			System.out.println(System.nanoTime() - startTime);
			System.exit(0);
		}
		return result;
	}

	public class MyTask implements Runnable {
		@Override
		public void run() {
			cdl.countDown();
			try {
				cdl.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			while (true)
				getAndIncreaseA();// getAndIncreaseB();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		AtomicTest at = new AtomicTest();
		for (int n = 0; n < THREAD_COUNT; n++)
			new Thread(at.new MyTask()).start();
		System.out.println("start");
		at.init();
		at.cdl.countDown();
	}
}

以下是在Intel(R) Core(TM) i7-4710HQ CPU @2.50GHz（四核八线程）下的测试结果(波动较小，所以每项只测试了四五次，取其中一个较中间的值)：
jdk1.7
AtomicInteger.getAndIncrement 12,653,757,034
synchronized 4,146,813,462
AtomicInteger.compareAndSet 12,952,821,234

jdk1.8
AtomicInteger.getAndIncrement 2,159,486,620
synchronized 4,067,309,911
AtomicInteger.compareAndSet 12,893,188,541


补充：应网友要求，在此提供Unsafe.getAndAddInt的相关源码以及我的测试代码。
用jad反编译jdk1.8中Unsafe得到的源码：

    public final int getAndAddInt(Object obj, long l, int i)
    {
        int j;
        do
            j = getIntVolatile(obj, l);
        while(!compareAndSwapInt(obj, l, j, j + i));
        return j;
    }
    public native int getIntVolatile(Object obj, long l);
    public final native boolean compareAndSwapInt(Object obj, long l, int i, int j);

openjdk8的Unsafe源码：

    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }
    public native int     getIntVolatile(Object o, long offset);
    public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);

我的测试代码(提示：如果eclipse等ide报错，那是因为使用了受限的Unsafe，可以将警告级别从error降为warning，具体百度即可)：

...
import sun.misc.Unsafe;
public class AtomicTest {
	....
	private Unsafe unsafe;
	private long valueOffset;
	public AtomicTest(){
		Field f;
		try {
			f = Unsafe.class.getDeclaredField("theUnsafe");
			f.setAccessible(true);
			unsafe = (Unsafe)f.get(null);
			valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
		}catch(NoSuchFieldException e){
		...
		}
	}
	private final int getAndIncreaseD(){
		int result;
		do{
			result = unsafe.getIntVolatile(ai, valueOffset);
		}while(!unsafe.compareAndSwapInt(ai, valueOffset, result, result+1));
		if(result == MAX){
			System.out.println(System.nanoTime()-startTime);
			System.exit(0);
		}
		return result;
	}
	...
}

补充2：对于性能提升的原因，有以下推论，虽不敢说百分之百正确（因为没有用jvm的源码作为论据），但还是有很大把握的，感谢网友@周 可人和@liuxinglanyue！

Unsafe是经过特殊处理的，不能理解成常规的java代码，区别在于：
在调用getAndAddInt的时候，如果系统底层支持fetch-and-add，那么它执行的就是native方法，使用的是fetch-and-add；
如果不支持，就按照上面的所看到的getAndAddInt方法体那样，以java代码的方式去执行，使用的是compare-and-swap；
这也正好跟openjdk8中Unsafe::getAndAddInt上方的注释相吻合：

// The following contain CAS-based Java implementations used on
// platforms not supporting native instructions

Unsafe的特殊处理也就是我上文所说的“黑魔法”。

时间： 2024-12-25 11:14:45

Java8中CAS的增强的相关文章

Internet Explorer 6 中的css增强之我见

css 天阅读了 msdn 上的 Internet Explorer 6 中的 CSS 增强功能 一文,感觉微软的确是为web 标准做了比较大的努力.按<网站重构>(Designing with web standards) 的说法,Internet Explorer 6 终于算是一个比较现代的浏览器了. 相对于它之前的版本,毋庸置疑,它的确是改进了不少,而且对 W3C标准支持得更好.比如,IE 6能够通过 标签进行"开关转换"(关于DOCTYPE开关,请参阅上文提到的文章

SQL Server 2005中的T-SQL增强

server 丰富的数据类型 Richer Data Types 1.varchar(max).nvarchar(max)和varbinary(max)数据类型最多可以保存2GB的数据,可以取代text.ntext或image数据类型.CREATE TABLE myTable(    id INT,    content VARCHAR(MAX)) 2.XML数据类型XML数据类型允许用户在SQL Server数据库中保存XML片段或文档. 错误处理 Error Handling 1.新的异常处

Function接口 – Java8中java.util.function包下的函数式接口

早先我写了一篇<函数式接口>,探讨了Java8中函数式接口的用法.如果你正在浏览Java8的API,你会发现java.util.function中 Function, Supplier, Consumer, Predicate和其他函数式接口广泛用在支持lambda表达式的API中.这些接口有一个抽象方法,会被lambda表达式的定义所覆盖.在这篇文章中,我会简单描述Function接口,该接口目前已发布在java.util.function中. Function接口的主要方法: R appl

初探Java8中的HashMap(转)

HashMap是我们最常用的集合之一,同时Java8也提升了HashMap的性能.本着学习的原则,在这探讨一下HashMap. 原理 简单讲解下HashMap的原理:HashMap基于Hash算法,我们通过put(key,value)存储,get(key)来获取.当传入key时,HashMap会根据key.hashCode()计算出hash值,根据hash值将value保存在bucket里.当计算出的hash值相同时怎么办呢,我们称之为Hash冲突,HashMap的做法是用链表和红黑树存储相同h

浅谈java8中map的新方法--replace_java

Map在Java8中新增了两个replace的方法 1.replace(k,v) 在指定的键已经存在并且有与之相关的映射值时才会将指定的键映射到指定的值(新值) 在指定的键不存在时,方法会return回来一个null javadoc的注释解释了该默认值方法的实现的等价Java代码: if (map.containsKey(key)) { return map.put(key, value); } else { return null; } 下面展示的是新方法和JDK8之前的方法比较: /* *

java8中的localdate和localtime用法举例

java8中的localdate和localtime用法举例如下:这两个方法使我们可以方便的实现将旧的日期类转换为新的日期类,具体思路都是通过Instant当中介,然后通过Instant来创建LocalDateTime(这个类可以很容易获取LocalDate和LocalTime),新的日期类转旧的也是如此,将新的先转成LocalDateTime,然后获取Instant,接着转成Date,具体实现细节如下: // 01. java.util.Date --> java.time.LocalDate

Java8中聚合操作collect、reduce方法详解

Stream的基本概念 Stream和集合的区别: Stream不会自己存储元素.元素储存在底层集合或者根据需要产生.Stream操作符不会改变源对象.相反,它会返回一个持有结果的新的Stream.3.Stream操作可能是延迟执行的,这意味着它们会等到需要结果的时候才执行.Stream操作的基本过程,可以归结为3个部分: 创建一个Stream.在一个或者多个操作中,将指定的Stream转换为另一个Stream的中间操作.通过终止(terminal)方法来产生一个结果.该操作会强制它之前的延时操

Java8中使用一行代码读取文件_java

JDK7中引入了新的文件操作类java.nio.file.File,它包含了很多有用的方法来操作文件,比如检查文件是否为隐藏文件,或者是检查文件是否为只读文件.开发者还可以使用Files.readAllBytes(Path)方法把整个文件读入内存,此方法返回一个字节数组,还可以把结果传递给String的构造器,以便创建字符串输出.此方法确保了当读入文件的所有字节内容时,文件属性是关闭的,否则就会出现IO异常或其它的未检查异常.这意味着在读文件到最后的块内容后,无需关闭文件. 要注意,此方法不适合

Java8中对泛型目标类型推断方法的改进_java

一.简单理解泛型 泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.通俗点将就是"类型的变量".这种类型变量可以用在类.接口和方法的创建中. 理解Java泛型最简单的方法是把它看成一种便捷语法,能节省你某些Java类型转换(casting)上的操作: 复制代码 代码如下: List<Apple> box = new ArrayList<Apple>();box.add(new Apple());Apple a