精华内容
下载资源
问答
  • 杰西姆·特姆吉 必需的 Java 8 玛文 要构建$> ./build.sh 运行jcstress测试$> ./run.sh 清理jcstress生成jcstress。 文件$> ./cleanup.sh
  • Java高并发测试框架JCStress

    热门讨论 2021-04-06 22:13:34
    目录前言如何使用Jcstress二、使用步骤1.引入库2.读入数据总结 前言 如果要研究高并发,一般会借助高并发工具来进行测试。Jcstress(Java Concurrency Stress)它是OpenJDK中的一个高并发测试工具,它可以帮助我们...

    前言

    如果要研究高并发,一般会借助高并发工具来进行测试。JCStress(Java Concurrency Stress)它是OpenJDK中的一个高并发测试工具,它可以帮助我们研究在高并发场景下JVM,类库以及硬件等状况。

    JCStress学起来很简单,而且官方也提供了许多高并发场景下的测试用例,只要引入一个jar包,即可运行研究。

    如何使用JCStress

    此演示用maven工程,首先需要引入jar包,核心包是必须要的,样例包非必须要,此是为了演示其中的例子。

    <dependencies>
        <!-- jcstress 核心包 -->
        <dependency>
            <groupId>org.openjdk.jcstress</groupId>
            <artifactId>jcstress-core</artifactId>
            <version>0.3</version>
        </dependency>
        <!-- jcstress测试用例包 -->
        <dependency>
            <groupId>org.openjdk.jcstress</groupId>
            <artifactId>jcstress-samples</artifactId>
            <version>0.3</version>
        </dependency>
    </dependencies>
    

    先写一个简单测试用例,一些注解不明白可以先不管,后面会讲解。此样例会在高并发下调用actor1和actor2方法各一次,按照正常逻辑,x最后的值要么是-1要么是5,如果actor2方法内的2行代码发生了指令重排序,就会导致x的值可能为0。

    package com.nobody;
    
    import org.openjdk.jcstress.annotations.*;
    import org.openjdk.jcstress.infra.results.I_Result;
    
    /**
     * @Description 测试指令重排序
     * @Author Mr.nobody
     * @Date 2021/4/6
     * @Version 1.0
     */
    @JCStressTest // 标记此类为一个并发测试类
    @Outcome(id = {"0"}, expect = Expect.ACCEPTABLE_INTERESTING, desc = "wrong result") // 描述测试结果
    @Outcome(id = {"-1", "5"}, expect = Expect.ACCEPTABLE, desc = "normal result") // 描述测试结果
    @State //标记此类是有状态的
    public class TestInstructionReorder {
    
        private boolean flag ;
        private int x;
    
        public TestInstructionReorder() {}
    
        @Actor
        public void actor1(I_Result r) {
            if (flag) {
                r.r1 = x;
            } else {
                r.r1 = -1;
            }
        }
    
        @Actor
        public void actor2(I_Result r) {
            this.x = 5;
            flag = true;
        }
    }
    

    配置程序的主类,org.openjdk.jcstress.Main是JCStress自带的一个启动类;然后可以配置-t参数设置需要测试的类,当然 -t 后面也可以指定包名,表示执行指定包下的所有测试类。如果不指定-t参数,默认会扫描项目下所有包的类。

    在这里插入图片描述

    运行程序,结果显示,x的值出现了0,-1,5三种结果,其中值为0不是我期待的,但是它在高并发下确实出现了,虽然相比其他值(几十万次)出现的概率(200多次)很低。

    在这里插入图片描述

    有些人会说用jmeter工具不也可以测试高并发,但是它们的侧重点还是不一样的,jmeter侧重对于接口整体的响应速度等进行测试,而JCStress框架能对某块逻辑代码进行高并发测试,更加侧重JVM,类库等领域的研究。

    而且,JCStress会考虑不同JVM参数设置下的测试,而且自动帮我们设置,例如上图所示[-XX:-TieredCompilation]。

    除了命令行窗口显示的测试结果之外,还会在项目所在的目录下生成 results文件夹,生成测试结果文档,其中index.html是测试总览,其他html文件是每个测试类的报告,结合结果数据结构可视化图形更加容易理解。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    JCStress 注解说明

    @JCStressTest

    标记一个类为并发测试的类,它有一个org.openjdk.jcstress.annotations.Mode枚举类型的属性value。Mode.Continuous模式表示会运行几个Actor,Ariter线程,并收集统计结果。Mode.Termination模式代表运行具有阻塞/循环操作的单个Actor,看是否响应Singal信号。

    @State

    标记一个类是有状态的,即拥有可以读写的数据,例如上例的x和falg。State类只能是public的,不能是内部类(可以是静态内部类),并且得有一个默认构造方法。

    @Outcome

    描述测试的结果,它有3个属性,id属性为一个字符串数组,表示接收的结果,支持正则表达式;expect表示对观测结果的期望,它的值是一个枚举值;desc属性指定一个易于人类理解的对结果的描述。@Outcomes注解可以组合多个结果注解。

    @Actor

    @Actor是一个中心测试注解,它标记的方法会被一个特定的线程调用,每一个对象的方法只能被调用一次。多个Actro方法调用顺序是不保证的,它们是并发执行的,方法可以抛出异常并且会导致测试失败。Actor方法所在的类必须有State或者Result注解。

    @Arbiter

    它的作用其实和@Actor差不多,但是Arbiter标记的方法调用是在所有@Actor标记的方法调用之后,所以它标记的方法一般作为收集最后的结果来使用。

    @Signal

    此注解也是标记方法的,但是它是在JCStressTest的Termination模式下工作的,它的调用是在所有Actor之后。

    @Result

    它标记的类被作为测试结果的类,JCStress自带的org.openjdk.jcstress.infra.results包下就有大量的测试结果类,不同的类可以用来保持不同的结果。例如I_Result类有一个int类型的变量r1;II_Result类有2个int类型的变量r1和r2。

    JCStress 插件

    有一个插件集成了JCStress和Gradle,我们只需要在build.gradle中引入此插件,即可使用插件命令来进行测试。插件依赖为jcstress-gradle-plugin。

    build.gradle文件如下,不同版本的插件集成了默认的JCStress版本,当然我们也可以自定义更改,如下最后一行所示。

    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'jcstress'
    
    buildscript {
        repositories {
            jcenter()
        }
    
        dependencies {
            classpath 'com.github.erizo.gradle:jcstress-gradle-plugin:0.8.1'
        }
    }
    
    
    ext {
        jcstressVersion = '0.7'
    }
    
    repositories {
        jcenter()
    }
    
    dependencies {
        compile "org.openjdk.jcstress:jcstress-core:${jcstressVersion}"
    }
    
    jcstress {
        jcstressDependency "org.openjdk.jcstress:jcstress-core:${jcstressVersion}"
    }
    

    然后在项目即可编写测试类,例如还是上面那个例子,最后我们在项目根目录下执行 gradle jcstress,即可显示测试结果。也可以通过参数指定要测试的类,例如 gradle jcstress --tests "TestInstructionReorder"

    插件源码地址:https://github.com/jerzykrlk/jcstress-gradle-plugin

    展开全文
  • jcstress 线程测试工具

    2018-08-02 14:38:11
    java多线程测试工具,可以用来测试多线程的执行状态。
  • jcstress 高并发测试框架使用教程 1. 创建Maven项目 1.1 修改pom文件 <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation=...

    jcstress 高并发测试框架使用教程

    1. 创建Maven项目

    1.1 修改pom文件

    <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.jcstress.learning</groupId>
        <artifactId>jcstress</artifactId>
        <version>1.0</version>
        <packaging>jar</packaging>
        <name>JCStress learning sample</name>
    
        <!--
           This is the demo/sample template build script for building concurrency tests with JCStress.
           Edit as needed.
        -->
    
        <prerequisites>
            <maven>3.0</maven>
        </prerequisites>
    
        <dependencies>
            <dependency>
                <groupId>org.openjdk.jcstress</groupId>
                <artifactId>jcstress-core</artifactId>
                <version>${jcstress.version}</version>
            </dependency>
            <dependency>
                <groupId>org.openjdk.jcstress</groupId>
                <artifactId>jcstress-samples</artifactId>
                <version>${jcstress.version}</version>
            </dependency>
        </dependencies>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    
            <!--
                jcstress version to use with this project.
              -->
            <jcstress.version>0.5</jcstress.version>
    
            <!--
                Java source/target to use for compilation.
              -->
            <javac.target>8</javac.target>
    
            <!--
                Name of the test Uber-JAR to generate.
              -->
            <uberjar.name>jcstress-learning</uberjar.name>
        </properties>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <configuration>
                        <compilerVersion>${javac.target}</compilerVersion>
                        <source>${javac.target}</source>
                        <target>${javac.target}</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                    <configuration>
                        <filesets>
                            <fileset>
                                <directory>${basedir}/results</directory>
                                <followSymlinks>false</followSymlinks>
                            </fileset>
                            <fileset>
                                <directory>${basedir}</directory>
                                <includes>
                                    <include>jcstress-results*</include>
                                </includes>
                                <followSymlinks>false</followSymlinks>
                            </fileset>
                        </filesets>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.2</version>
                    <executions>
                        <execution>
                            <id>main</id>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <finalName>${uberjar.name}</finalName>
                                <transformers>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <mainClass>org.openjdk.jcstress.Main</mainClass>
                                    </transformer>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                        <resource>META-INF/TestList</resource>
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    2. 创建测试类或者使用官方Demo

    2.1 使用官方demo

    官方demo下载地址, GitHub的demo示例

    2.2 自己创建测试类

    public class TestJMM {
    		
      	// 指定使用并发测试
        @JCStressTest
        // 预测的结果与类型,附加描述信息
        @Outcome(id = {"0, 1", "1, 0", "1, 1"}, expect = ACCEPTABLE, desc = "Trivial under sequential consistency")
        @Outcome(id = "0, 0", expect = ACCEPTABLE_INTERESTING, desc = "Violates sequential consistency")
        // 标注需要测试的类
        @State
        public static class PlainExecutionOrder {
            int x, y;
            int i, j;
    				
          	// 标记方法使用多线程
            @Actor
            public void actor1(II_Result r) {
                x = 1;
                r.r2 = y;
            }
    
            @Actor
            public void actor2(II_Result r) {
                y = 1;
                r.r1 = x;
            }
    
        }
    }
    

    3 打包并启动

    必须使用mvn clean install打包成jar包否则会缺失文件无法运行

    3.1 启动命令

    java -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-RestrictContended -jar target/jcstress-learning.jar -v -t TestJMM.PlainExecutionOrder
    

    参考文章:

    https://www.jianshu.com/p/aa0e7d0bf158

    https://wiki.openjdk.java.net/display/CodeTools/jcstress

    https://github.com/jwoschitz/jcstress-examples

    https://github.com/jerzykrlk/jcstress-gradle-plugin

    https://stackoverflow.com/questions/53458367/running-first-jcstress-test

    展开全文
  • 学习高并发使用的工具 遇到以下问题: 按照百度上面的流程,直接移植到springboot项目中测试,发现每次install都会报错 [ERROR] Failed to execute...无法生成jcstress.jar包,继而无法测试 解决方案: 重新创建一

    学习高并发使用的工具

    遇到以下问题:

    按照百度上面的流程,直接移植到springboot项目中测试,发现每次install都会报错

    [ERROR] Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.22.2:test (default-test) on project demo1: There are test failures.

    无法生成jcstress.jar包,继而无法测试

    解决方案:

    重新创建一个新的maven项目

    pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.openjdk.jcstress</groupId>
        <artifactId>jcstress-core</artifactId>
        <version>1.0-SNAPSHOT</version>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <!-- jcstress版本 -->
            <jcstress.version>0.5</jcstress.version>
            <!-- jdk版本 -->
            <javac.target>1.8</javac.target>
            <uberjar.name>jcstress</uberjar.name>
        </properties>
    
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.openjdk.jcstress/jcstress-core -->
            <dependency>
                <groupId>org.openjdk.jcstress</groupId>
                <artifactId>jcstress-core</artifactId>
                <version>0.3</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <!-- jar生成路径 -->
                    <configuration>
                        <compilerVersion>${javac.target}</compilerVersion>
                        <source>${javac.target}</source>
                        <target>${javac.target}</target>
                    </configuration>
                </plugin>
    
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <!-- 将依赖的jar包打包到当前jar包 -->
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.2</version>
                    <executions>
                        <execution>
                            <id>main</id>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <!-- 打包的名字 jcstress.jar -->
                                <finalName>${uberjar.name}</finalName>
                                <!-- 调用下面下面两个类 -->
                                <transformers>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <mainClass>org.openjdk.jcstress.Main</mainClass>
                                    </transformer>
                                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                        <resource>META-INF/TestList</resource>
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    
    
    
    </project>
    

    测试类

    package com.hikktn;
    
    import org.openjdk.jcstress.annotations.*;
    import org.openjdk.jcstress.infra.results.II_Result;
    
    @JCStressTest
    @State
    //             r1  r2
    @Outcome(id = "1, 0", expect = Expect.ACCEPTABLE)
    @Outcome(id = "0, 2", expect = Expect.ACCEPTABLE)
    @Outcome(id = "1, 2", expect = Expect.ACCEPTABLE)
    @Outcome(id = "0, 0", expect = Expect.ACCEPTABLE_INTERESTING)
    public class Test4Possible {
        int a;
        int b;
        @Actor
        public void action1(II_Result r) {
            a = 1;
            r.r2 = b;
        }
        @Actor
        public void action2(II_Result r) {
            b = 2;
            r.r1 = a;
        }
    }
    

    项目结构 

    项目结构

    操作 

    注意点

    每次新建测试类,需要重新clean后,再次install。执行成功后,执行  java -jar target/jcstress.jar

    效果如下

    链接:https://pan.baidu.com/s/18khs_eId6XBPGHkSvMsj-w 
    提取码:d3xu 
    复制这段内容后打开百度网盘手机App,操作更方便哦

    展开全文
  • jcstress搭建

    2021-06-30 11:47:30
    pom.xml <prerequisites> <maven>3.0</maven> </prerequisites> <properties> <project.build.source...jcstress.version>0.5</jcstress.version> <jav

    pom.xml

    <prerequisites>
    		<maven>3.0</maven>
    	</prerequisites>
    	
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<jcstress.version>0.5</jcstress.version>
    		<javac.target>8</javac.target>
    		<uberjar.name>jcstress-learning</uberjar.name>
    	</properties>
    	
    	<dependencies>
    		<dependency>
    			<groupId>org.openjdk.jcstress</groupId>
    			<artifactId>jcstress-core</artifactId>
    			<version>${jcstress.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.openjdk.jcstress</groupId>
    			<artifactId>jcstress-samples</artifactId>
    			<version>${jcstress.version}</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<version>3.1</version>
    				<configuration>
    					<compilerVersion>${javac.target}</compilerVersion>
    					<source>${javac.target}</source>
    					<target>${javac.target}</target>
    				</configuration>
    			</plugin>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-clean-plugin</artifactId>
    				<version>3.1.0</version>
    				<configuration>
    					<filesets>
    						<fileset>
    							<directory>${basedir}/results</directory>
    							<followSymlinks>false</followSymlinks>
    						</fileset>
    						<fileset>
    							<directory>${basedir}</directory>
    							<includes>
    								<include>jcstress-results*</include>
    							</includes>
    							<followSymlinks>false</followSymlinks>
    						</fileset>
    					</filesets>
    				</configuration>
    			</plugin>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-shade-plugin</artifactId>
    				<version>2.2</version>
    				<executions>
    					<execution>
    						<id>main</id>
    						<phase>package</phase>
    						<goals>
    							<goal>shade</goal>
    						</goals>
    						<configuration>
    							<finalName>${uberjar.name}</finalName>
    							<transformers>
    								<transformer
    									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
    									<mainClass>org.openjdk.jcstress.Main</mainClass>
    								</transformer>
    								<transformer
    									implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
    									<resource>META-INF/TestList</resource>
    								</transformer>
    							</transformers>
    						</configuration>
    					</execution>
    				</executions>
    			</plugin>
    		</plugins>
    	</build>

    eclipse 运行设置

    运行完成后,在results内查看结果html文件

    展开全文
  • 如何在IDEA中使用jcstress进行并发压力测试 1.创建maven项目 ​ 通过mvn archetype:generate这种交互方式来创建Maven项目。 mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk....
  • 并发测试工具Jcstress使用教程 Jcstress 全称 Java Concurrency Stress,是一种并发压力测试工具,可以帮助研究JVM、java类库和硬件中并发的正确性。 Wiki地址:...
  • 使用 jcstress 测试并发程序确性

    千次阅读 2016-01-27 14:07:30
    使用 jcstress 测试并发程序确性
  • Java高并发测试框架jcstress详解
  • -DarchetypeGroupId=org.openjdk.jcstress -DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.1.1 -DgroupId=org.sample -DartifactId= test -Dversion=1.0 $ cd test $ echo '...
  • 有序性 指程序中代码的执行顺序,java在编译和运行时会对代码进行优化,会导致最后程序的执行顺序不一定是我们编写代码的顺序 这个测试类有点难写,借用了一个jsrtress包 org.openjdk.jcstress jcstress-core 0.7 ...
  • Java并发编程总结

    2021-04-11 15:01:23
    1进程/线程是什么? 进程是“执行中的程序”,进行资源分配和调度的独立单位,线程是进程的实体,一个进程可以拥有多个线程,线程的上下文切换比进程要快,线程之间共享地址空间和其他资源。 2线程状态?...
  • 文章目录程序、进程、线程的理解并行与并发单核CPU与多核CPU的理解并行与并发的理解创建线程的几种方法继承Thread类创建线程实现Runnable接口创建线程Thread和Runnable的关系Runnable接口构造线程源码Thread类构造...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 220
精华内容 88
关键字:

jcstress