测试模型

基于JMH基准测试库

测试代码

package com.lsy.study.benchmark;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.StampedLock;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 2, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@Threads(2)
public class SyncTest {

    static class TaskStack {

        private volatile int task;

        TaskStack() {
            this.task = 10000000;
        }

        int getTask() {
            this.task = this.task - 1;
            return this.task;
        }
    }

    @Setup
    public void prepare() {
    }

    @Benchmark
    public void synchronizedKeyWord() {
        Object lock = new Object();
        CountDownLatch countDownLatch = new CountDownLatch(50);
        TaskStack taskStack = new TaskStack();
        for (int i = 0; i < 50; i++) {
            new Thread(() -> {
                while (true) {
                    synchronized (lock) {
                        int task = taskStack.getTask();
                        if (task <= 0) {
                            break;
                        }
                    }
                }
                countDownLatch.countDown();
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    @Benchmark
    public void reenterLock() {
        ReentrantLock reentrantLock = new ReentrantLock();
        CountDownLatch countDownLatch = new CountDownLatch(50);
        TaskStack taskStack = new TaskStack();
        for (int i = 0; i < 50; i++) {
            new Thread(() -> {
                while (true) {
                    reentrantLock.lock();
                    try {
                        int task = taskStack.getTask();
                        if (task <= 0) {
                            break;
                        }
                    } finally {
                        reentrantLock.unlock();
                    }
                }
                countDownLatch.countDown();
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Benchmark
    public void stampedLock() {
        StampedLock stampedLock = new StampedLock();
        CountDownLatch countDownLatch = new CountDownLatch(50);
        TaskStack taskStack = new TaskStack();
        for (int i = 0; i < 50; i++) {
            new Thread(() -> {
                while (true) {
                    stampedLock.writeLock();
                    try {
                        int task = taskStack.getTask();
                        if (task <= 0) {
                            break;
                        }
                    } finally {
                        stampedLock.tryUnlockWrite();
                    }
                }
                countDownLatch.countDown();
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(SyncTest.class.getSimpleName())
                .resultFormat(ResultFormatType.JSON)
                .build();
        new Runner(opts).run();
    }


}