blocks|key|51391|text|TestNG提供了良好的开箱即用的多线程测试，并且它与JUnit测试兼容(您需要做一些更改)。例如，您可以像这样运行一个测试：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|51392|@Test(threadPoolSize+=+3,+invocationCount+=+9,++timeOut+=+10000)
public+void+doSomething()+{
...
}|code-block|syntax|javascript|51393|这意味着doSomething()方法将被3个不同的线程调用9次。|CODE|51394|我强烈推荐TestNG。|51395|entityMap^0|0|6|0|0|4|D|0|5|6|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|V|8|@$9|W|A|X|B|M]]|D|@]|E|$]]|$1|N|3|O|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|Q|$]]

Are you fixed to JUnit? TestNG provides good multi thread testing out of the box and it's compatible with JUnit tests (you need to make a few changes). For example you could run a test like this:

<pre><code>@Test(threadPoolSize = 3, invocationCount = 9, timeOut = 10000)
public void doSomething() {
...
}
</code></pre>

This would mean that the <code>doSomething()</code> method will be invoked 9 times by 3 different threads.

I highly recommend TestNG.

blocks|key|51397|text|我正在寻找这个问题的答案，根据这里的答案，以及我在其他地方读到的，目前似乎没有一种简单的开箱即用的方法来使用JUnit并行运行现有的测试。或者如果有我也没找到。所以我写了一个简单的JUnit运行器来实现这一点。请随时使用它；有关MultiThreadedRunner类的完整解释和源代码，请参阅http://falutin.net/2012/12/30/multithreaded-testing-with-junit/。有了这个类，您就可以像这样注释您现有的测试类：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|51398|@RunWith(MultiThreadedRunner.class)|code-block|syntax|javascript|51399|entityMap|0|LINK|mutability|MUTABLE|url|http://falutin.net/2012/12/30/multithreaded-testing-with-junit/^0|43|1R|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I was looking for an answer to exactly this question, and based on the answers here, and what I read elsewhere, it appears as if there isn't currently an easy out-of-the-box way to run existing tests in parallel using JUnit. Or if there is I didn't find it. So I wrote a simple JUnit Runner that accomplishes that. Please feel free to use it; see <a href="http://falutin.net/2012/12/30/multithreaded-testing-with-junit/">http://falutin.net/2012/12/30/multithreaded-testing-with-junit/</a> for a complete explanation and the source code of the MultiThreadedRunner class. With this class, you can just annotate your existing test class(es) like this:

<pre><code>@RunWith(MultiThreadedRunner.class)
</code></pre>

blocks|key|51066|text|您也可以尝试使用HavaRunner。默认情况下，它是并行运行测试的JUnit运行器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|51067|HavaRunner还有一些方便的套件:您可以通过在类上添加注释@PartOf(YourIntegrationTestSuite.class)来声明测试是套件的成员。这种方法与JUnit的方法不同，JUnit的方法是在suite类中声明套件成员资格。|style|CODE|51068|此外，HavaRunner套件可以初始化重量级对象，如嵌入式web应用程序容器。然后，HavaRunner将这个重量级对象传递给每个套件成员的构造函数。这消除了对@BeforeClass和@AfterClass注释的需要，这是有问题的，因为它们促进了全局可变状态，这反过来又使得并行化变得困难。|51069|最后，HavaRunner具有场景-一种对不同数据运行相同测试的方法。场景减少了重复测试代码的需要。|51070|HavaRunner已经在两个中等规模的Java项目中进行了战斗测试。|51071|Ps。我是HavaRunner的作者，非常感谢您的反馈。|51072|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/havarunner/havarunner^0|8|A|0|0|W|13|0|29|C|2M|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@$A|12|B|13|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|14|8|@$A|15|B|16|F|G]|$A|17|B|18|F|G]]|9|@]|C|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1A|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

You can also try <a href="https://github.com/havarunner/havarunner" rel="nofollow">HavaRunner</a>. It is a JUnit runner that runs tests in parallel by default.

HavaRunner also has handy suites: you can declare a test to be a member of a suite by adding the annotation <code>@PartOf(YourIntegrationTestSuite.class)</code> onto the class. This approach differs from JUnit's, where you declare the suite memberships in the suite class. 

In addition, HavaRunner suites may intialise heavy-weight objects such as an embedded web application container. HavaRunner then passes this heavy-weight object to the constructor of each suite member. This removes the need for the <code>@BeforeClass</code> and <code>@AfterClass</code> annotations, which are problematic, because they promote global mutable state, which in turn makes parallelisation difficult.

Lastly, HavaRunner has scenarios – a way to run the same test against different data. Scenarios reduce the need to duplicate test code.

HavaRunner has been battle-tested in two mid-size Java projects.

Ps. I'm the author of HavaRunner, and I'd appreciate your feedback on it.

blocks|key|2744253|text|显然，在他的帖子“使用RunnerScheduler进行并发JUnit测试”中，Mathieu+Carbou已经为并发做了实现，这可能会有所帮助！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2744254|http://dzone.com/articles/concurrent-junit-tests|offset|length|2744255|OneJunit|2744256|@RunWith(ConcurrentJunitRunner.class)
@Concurrent(threads+=+6)
public+final+class+ATest+{
+
++++@Test+public+void+test0()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test1()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test2()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test3()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test4()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test5()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test6()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test7()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test8()+throws+Throwable+{+printAndWait();+}
++++@Test+public+void+test9()+throws+Throwable+{+printAndWait();+}

++++void+printAndWait()+throws+Throwable+{
++++++++int+w+=+new+Random().nextInt(1000);
++++++++System.out.println(String.format("[%25s]+%25s+%25s+%25s",Thread.currentThread().getName(),+getClass().getName(),+new+Throwable+++++++().getStackTrace()[1].getMethodName(),+w));
++++++++Thread.sleep(w);
++++}
}|code-block|syntax|javascript|2744257|多个JUnits：|2744258|@RunWith(ConcurrentSuite.class)
@Suite.SuiteClasses({ATest.class,+ATest2.class,+ATest3.class})
public+class+MySuite+{
}|2744259|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|C]]]]

Apparently in his post &quot;Concurrent JUnit Tests With RunnerScheduler&quot; Mathieu Carbou has done implementation for concurrence that could helps!
<a href="http://dzone.com/articles/concurrent-junit-tests" rel="nofollow noreferrer">http://dzone.com/articles/concurrent-junit-tests</a>
OneJunit
<pre><code>@RunWith(ConcurrentJunitRunner.class)
@Concurrent(threads = 6)
public final class ATest {
 
 @Test public void test0() throws Throwable { printAndWait(); }
 @Test public void test1() throws Throwable { printAndWait(); }
 @Test public void test2() throws Throwable { printAndWait(); }
 @Test public void test3() throws Throwable { printAndWait(); }
 @Test public void test4() throws Throwable { printAndWait(); }
 @Test public void test5() throws Throwable { printAndWait(); }
 @Test public void test6() throws Throwable { printAndWait(); }
 @Test public void test7() throws Throwable { printAndWait(); }
 @Test public void test8() throws Throwable { printAndWait(); }
 @Test public void test9() throws Throwable { printAndWait(); }

 void printAndWait() throws Throwable {
 int w = new Random().nextInt(1000);
 System.out.println(String.format(&quot;[%s] %s %s %s&quot;,Thread.currentThread().getName(), getClass().getName(), new Throwable ().getStackTrace()[1].getMethodName(), w));
 Thread.sleep(w);
 }
}
</code></pre>
Multiple JUnits:
<pre><code>@RunWith(ConcurrentSuite.class)
@Suite.SuiteClasses({ATest.class, ATest2.class, ATest3.class})
public class MySuite {
}
</code></pre>

blocks|key|2744324|text|下面的代码应该可以满足您的需求，它取自德语书籍JUnit+Profiwissen，其中包含一些关于并行测试的提示，或者关于如何通过使用多个内核而不是只使用一个内核来减少执行时间的提示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2744325|JUnit+4.6引入了一个ParallelComputer类，它提供了测试的并行执行。然而，直到JUnit+4.7才能公开访问此功能，该功能提供了为父运行器设置自定义调度程序的可能性。|2744326|public+class+ParallelScheduler+implements+RunnerScheduler+{

++++private+ExecutorService+threadPool+=+Executors.newFixedThreadPool(
++++++++Runtime.getRuntime().availableProcessors());

++++@Override
++++public+void+schedule(Runnable+childStatement)+{
++++++++threadPool.submit(childStatement);
++++}

++++@Override
++++public+void+finished()+{
++++++++try+{
++++++++++++threadPool.shutdown();
++++++++++++threadPool.awaitTermination(Long.MAX_VALUE,+TimeUnit.NANOSECONDS);
++++++++}+catch+(InterruptedException+e)+{
++++++++++++Thread.currentThread().interrupt();
++++++++++++throw+new+RuntimeException("Got+interrupted",+e);
++++++++}
++++}
}

public+class+ParallelRunner+extends+BlockJUnit4ClassRunner+{

++++public+ParallelRunner(Class<?>+klass)+throws+InitializationError+{
++++++++super(klass);
++++++++setScheduler(new+ParallelScheduler());
++++}
}|code-block|syntax|javascript|2744327|如果现在使用@RunWith(ParallelRunner.class)注释测试类，则每个方法都将在其自己的线程中运行。此外，在执行机器上，将有与CPU核心一样多的活动线程(仅限)。|style|CODE|2744328|如果需要并行执行多个类，您可以定义一个自定义套件，如下所示：|2744329|public+class+ParallelSuite+extends+Suite+{

++++public+ParallelSuite(Class<?>+klass,+RunnerBuilder+builder)+
++++++throws+InitializationError+{
++++++++super(klass,+builder);
++++++++setScheduler(new+ParallelScheduler());
++++}
}|2744330|然后用@RunWith(ParallelSuite.class)更改@RunWith(Suite.class)|2744331|您甚至可以利用f.e.的功能。通过直接从套件扩展WildcardPatternSuite，而不是像前面示例中那样扩展Suite。这使您能够进一步过滤单元测试f.e.任何@Category+-一个只并行执行UnitTest注释类别的TestSuite可能如下所示：|2744332|public+interface+UnitTest+{

}

@RunWith(ParallelSuite.class)
@SuiteClasses("**/*Test.class")
@IncludeCategories(UnitTest.class)
public+class+UnitTestSuite+{

}|2744333|一个简单的测试用例现在可能如下所示：|2744334|@Category(UnitTest.class)
@RunWith(MockitoJUnitRunner.class)
public+class+SomeClassTest+{

++++@Test
++++public+void+testSomething()+{
++++++++...
++++}
}|2744335|UnitTestSuite将执行在以Test结尾的子目录中找到的每个类，并具有并行指定的@Category(UnitTest.class)+-这取决于可用CPU核心的数量。|2744336|我不确定还能不能变得更简单:)|2744337|entityMap|0|LINK|mutability|MUTABLE|url|http://www.amazon.de/JUnit-Profiwissen-Effizientes-Arbeiten-Standardbibliothek-automatische/dp/3864900204/ref=sr_1_1?ie=UTF8&qid=1412676922&sr=8-1&keywords=JUnit^0|N|H|0|0|0|0|6|U|0|0|0|3|T|Y|L|0|O|K|1M|5|2C|9|2U|8|0|0|0|0|0|D|I|4|18|P|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|D|3|E|5|6|7|1I|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1J|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1K|8|@$A|1L|B|1M|M|N]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1N|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1O|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1P|8|@$A|1Q|B|1R|M|N]|$A|1S|B|1T|M|N]]|9|@]|C|$]]|$1|U|3|V|5|6|7|1U|8|@$A|1V|B|1W|M|N]|$A|1X|B|1Y|M|N]|$A|1Z|B|20|M|N]|$A|21|B|22|M|N]]|9|@]|C|$]]|$1|W|3|X|5|H|7|23|8|@]|9|@]|C|$I|J]]|$1|Y|3|Z|5|6|7|24|8|@]|9|@]|C|$]]|$1|10|3|11|5|H|7|25|8|@]|9|@]|C|$I|J]]|$1|12|3|13|5|6|7|26|8|@$A|27|B|28|M|N]|$A|29|B|2A|M|N]|$A|2B|B|2C|M|N]]|9|@]|C|$]]|$1|14|3|15|5|6|7|2D|8|@]|9|@]|C|$]]|$1|16|3|-4|5|6|7|2E|8|@]|9|@]|C|$]]]|17|$18|$5|19|1A|1B|C|$1C|1D]]]]

The following code should achieve your requirements which was taken from the German book <a href="http://www.amazon.de/JUnit-Profiwissen-Effizientes-Arbeiten-Standardbibliothek-automatische/dp/3864900204/ref=sr_1_1?ie=UTF8&amp;qid=1412676922&amp;sr=8-1&amp;keywords=JUnit" rel="noreferrer">JUnit Profiwissen</a> which contains some hints to either tests stuff in parallel or on how to reduce execution time through using multiple cores instead of only a single core.

JUnit 4.6 introduced a ParallelComputer class which offered the parallel execution of tests. However, this functionality was not publicly accessible until JUnit 4.7 which provided the possibility to set a custom scheduler for the parent runner.

<pre><code>public class ParallelScheduler implements RunnerScheduler {

 private ExecutorService threadPool = Executors.newFixedThreadPool(
 Runtime.getRuntime().availableProcessors());

 @Override
 public void schedule(Runnable childStatement) {
 threadPool.submit(childStatement);
 }

 @Override
 public void finished() {
 try {
 threadPool.shutdown();
 threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 throw new RuntimeException("Got interrupted", e);
 }
 }
}

public class ParallelRunner extends BlockJUnit4ClassRunner {

 public ParallelRunner(Class&lt;?&gt; klass) throws InitializationError {
 super(klass);
 setScheduler(new ParallelScheduler());
 }
}
</code></pre>

If you now annotate a test-class with <code>@RunWith(ParallelRunner.class)</code> each method will run within its own thread. Furthermore, there will be as many active threads (only) as CPU-cores are available at the executing machine.

If multiple classes should be executed in parallel you can define a customized suite like this:

<pre><code>public class ParallelSuite extends Suite {

 public ParallelSuite(Class&lt;?&gt; klass, RunnerBuilder builder) 
 throws InitializationError {
 super(klass, builder);
 setScheduler(new ParallelScheduler());
 }
}
</code></pre>

and then change <code>@RunWith(Suite.class)</code> with <code>@RunWith(ParallelSuite.class)</code>

You can even leverage the functionality of f.e. the <code>WildcardPatternSuite</code> by extending directly from that suite instead of <code>Suite</code> as in the example before. This enables you furthermore to filter unit-tests f.e. by any <code>@Category</code> - a TestSuite which only executes <code>UnitTest</code> annotated categories in parallel could look like this:

<pre><code>public interface UnitTest {

}

@RunWith(ParallelSuite.class)
@SuiteClasses("**/*Test.class")
@IncludeCategories(UnitTest.class)
public class UnitTestSuite {

}
</code></pre>

A simple test case could now look like this:

<pre><code>@Category(UnitTest.class)
@RunWith(MockitoJUnitRunner.class)
public class SomeClassTest {

 @Test
 public void testSomething() {
 ...
 }
}
</code></pre>

The <code>UnitTestSuite</code> will execute each class found in subdirecotries that ends with <code>Test</code> and has a <code>@Category(UnitTest.class)</code> specified in parallel - depending on the number of CPU cores available.

I'm not sure if it can get simpler than that :)

I have a large JUnit test suite, where I'd quite like to run all the tests concurrently for two reasons:

<ul>
<li>Exploit multiple cores to run the whole test suite faster</li>
<li>Hopefully detect some errors due to non-thread-safe global objects </li>
</ul>

I recognise that this will force me to refactor some code to make it thread-safe, but I consider that to be a good thing :-)

What's the best way to get JUnit to run all the tests concurrently?

Concurrent JUnit testing

单元测试

容器

Java

我有一个很大的JUnit测试套件，我非常希望在其中并发运行所有测试，原因有两个：利用多核来运行整个测试套件fasterHopefully检测由于非线程安全全局对象而导致的错误我认识到这将迫使我重构一些代码，使其成为线程安全的，但我认为这是一件好事:-)让JUnit同时运行所有测试的最佳方法是什么？

问并发JUnit测试
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问并发JUnit测试EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问并发JUnit测试
EN