Java 锁机制性能初探

前言

环境	备注
JDK	版本 11
OS	Win10
CPU	AMD R7 4800U
内存	16G
磁盘	SAMSUNG MZVLB512HBJQ-000L 2

main方法测试，非专业测试方式，存在一定的误差，但也具有一定的参考价值

测试的锁类型

锁方式	对应方法
synchronized 方法锁	syncByMethod
synchronized 常量锁	syncByConstant
synchronized 对象锁	syncByObj
StampedLock 写锁	stampedLock
ReentrantLock	reentrantLock

结果

测试代码

package org.example.thread;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import com.google.common.collect.Lists;
import lombok.SneakyThrows;

import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.StampedLock;
import java.util.stream.Collectors;

/**
 * @author utrix
 * @date 2021/1/10
 */
public class LockDemo {

    private static long count = 0;
    public static final String LOCK_KEY = LockDemo.class.getSimpleName();
    public static final int RUN_NUMBER = 100;
    // public static final int RUN_NUMBER = 100*100;
    public static final int TEST_NUMBER = 20 * 100;
    public static final ArrayList<Long> TIME_COUNT = Lists.newArrayListWithCapacity(TEST_NUMBER);

    /*
    总结：synchronized经过不断的优化，到目前JDK8版本已经不再是低级笨重的锁了，在一起其他场合性能已经优于reentrantLoack和stampedLock了
    原因：synchronized引入了偏向锁、轻量级锁、重量级锁，并提供了自动的升级降级机制
     */

    @SneakyThrows
    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();
        lockDemo.avgCount("syncByConstant",lockDemo::syncByConstant);
        // lockDemo.avgCount("syncByObj",lockDemo::syncByObj);
        // lockDemo.avgCount("reentrantLock",lockDemo::reentrantLock);
        // lockDemo.avgCount("stampedLock",lockDemo::stampedLock);
        // lockDemo.avgCount("syncByMethod",lockDemo::syncByMethod);
    }

    private void avgCount(String type, Runnable run) {
        for (int i = 0; i < TEST_NUMBER; i++) {
            runByDefine(type, run);
        }
        Double avg = TIME_COUNT.stream().collect(Collectors.averagingLong(Long::longValue));
        System.err.printf("%s 方式用时最长 %d 毫秒, 最短 %d 毫秒, 平均 %f 毫秒 \n", type, CollUtil.max(TIME_COUNT),
                CollUtil.min(TIME_COUNT), avg);
    }

    private void runByDefine(String type, Runnable run) {
        TimeInterval timer = DateUtil.timer();
        for (int i = 0; i < RUN_NUMBER; i++) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    run.run();
                }
            };
            thread.start();
        }
        long time = timer.intervalMs();
        TIME_COUNT.add(time);
        System.out.printf("%s 方式执行用时 %d 毫秒 \n", type, time);
    }

    /**
     * synchronized 方法锁
     * 方法锁锁定的该方法所属对象隐藏字段的monitor
     */
    private synchronized void syncByMethod() {
        count++;
    }

    /**
     * synchronized 对象锁
     */
    private void syncByObj() {
        synchronized (this) {
            count++;
        }
    }

    /**
     * synchronized 常量锁
     */
    private void syncByConstant() {
        synchronized (LOCK_KEY) {
            count++;
        }
    }

    /**
     * JDK8 StampedLock锁
     */
    private void stampedLock() {
        StampedLock lock = new StampedLock();
        Lock writeLock = lock.asWriteLock();
        try {
            writeLock.lock();
            count++;
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * ReentrantLock 锁
     */
    private void reentrantLock() {
        ReentrantLock reentrantLock = new ReentrantLock();
        try {
            reentrantLock.lock();
            count++;
        } finally {
            reentrantLock.unlock();
        }
    }

}

(本文完！如需转载请付本文链接！)