mindol1004/spring-soap
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved thread local random examples from core-java-concurrency-advanced to core-java-concurrency-advanced-2

Browse Source
This commit is contained in:
fejera
2019-09-29 11:43:37 +02:00
parent 487c0df482
commit 2940c2bde5
7 changed files with 14 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core-java-modules/core-java-concurrency-advanced/README.md
View File

@@ -14,6 +14,5 @@
- [CyclicBarrier in Java](https://www.baeldung.com/java-cyclic-barrier)
- [Guide to the Volatile Keyword in Java](https://www.baeldung.com/java-volatile)
- [Guide to ThreadLocalRandom in Java](https://www.baeldung.com/java-thread-local-random)
- [The Thread.join() Method in Java](https://www.baeldung.com/java-thread-join)
- [Passing Parameters to Java Threads](https://www.baeldung.com/java-thread-parameters)

12
core-java-modules/core-java-concurrency-advanced/pom.xml
View File

@@ -47,16 +47,6 @@
<version>${avaitility.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>${jmh-core.version}</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>${jmh-generator-annprocess.version}</version>
</dependency>
</dependencies>
<build>
@@ -78,8 +68,6 @@
<!-- testing -->
<assertj.version>3.6.1</assertj.version>
<avaitility.version>1.7.0</avaitility.version>
<jmh-core.version>1.19</jmh-core.version>
<jmh-generator-annprocess.version>1.19</jmh-generator-annprocess.version>
</properties>
</project>

22
core-java-modules/core-java-concurrency-advanced/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarkRunner.java
View File

@@ -1,22 +0,0 @@
package com.baeldung.threadlocalrandom;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
public class ThreadLocalRandomBenchMarkRunner {
public static void main(String[] args) throws Exception {
Options options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
.threads(1)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.jvmArgs("-server")
.build();
new Runner(options).run();
}
}

64
core-java-modules/core-java-concurrency-advanced/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarker.java
View File

@@ -1,64 +0,0 @@
package com.baeldung.threadlocalrandom;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 1)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
public class ThreadLocalRandomBenchMarker {
List<Callable<Integer>> randomCallables = new ArrayList<>();
List<Callable<Integer>> threadLocalRandomCallables = new ArrayList<>();
@Setup(Level.Iteration)
public void init() {
Random random = new Random();
randomCallables = new ArrayList<>();
threadLocalRandomCallables = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
randomCallables.add(() -> {
return random.nextInt();
});
}
for (int i = 0; i < 1000; i++) {
threadLocalRandomCallables.add(() -> {
return ThreadLocalRandom.current()
.nextInt();
});
}
}
@Benchmark
public void randomValuesUsingRandom() throws InterruptedException {
ExecutorService executor = Executors.newWorkStealingPool();
executor.invokeAll(randomCallables);
executor.shutdown();
}
@Benchmark
public void randomValuesUsingThreadLocalRandom() throws InterruptedException {
ExecutorService executor = Executors.newWorkStealingPool();
executor.invokeAll(threadLocalRandomCallables);
executor.shutdown();
}
}

63
core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/threadlocalrandom/ThreadLocalRandomIntegrationTest.java
View File

@@ -1,63 +0,0 @@
package com.baeldung.threadlocalrandom;
import java.util.concurrent.ThreadLocalRandom;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
public class ThreadLocalRandomIntegrationTest {
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomIntBounded_thenCorrect() {
int leftLimit = 1;
int rightLimit = 100;
int generatedInt = ThreadLocalRandom.current().nextInt(leftLimit, rightLimit);
assertTrue(generatedInt < rightLimit && generatedInt >= leftLimit);
}
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomIntUnbounded_thenCorrect() {
int generatedInt = ThreadLocalRandom.current().nextInt();
assertTrue(generatedInt < Integer.MAX_VALUE && generatedInt >= Integer.MIN_VALUE);
}
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomLongBounded_thenCorrect() {
long leftLimit = 1L;
long rightLimit = 100L;
long generatedLong = ThreadLocalRandom.current().nextLong(leftLimit, rightLimit);
assertTrue(generatedLong < rightLimit && generatedLong >= leftLimit);
}
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomLongUnbounded_thenCorrect() {
long generatedInt = ThreadLocalRandom.current().nextLong();
assertTrue(generatedInt < Long.MAX_VALUE && generatedInt >= Long.MIN_VALUE);
}
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomDoubleBounded_thenCorrect() {
double leftLimit = 1D;
double rightLimit = 100D;
double generatedInt = ThreadLocalRandom.current().nextDouble(leftLimit, rightLimit);
assertTrue(generatedInt < rightLimit && generatedInt >= leftLimit);
}
@Test
public void givenUsingThreadLocalRandom_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
double generatedInt = ThreadLocalRandom.current().nextDouble();
assertTrue(generatedInt < Double.MAX_VALUE && generatedInt >= Double.MIN_VALUE);
}
@Test(expected = UnsupportedOperationException.class)
public void givenUsingThreadLocalRandom_whenSettingSeed_thenThrowUnsupportedOperationException() {
ThreadLocalRandom.current().setSeed(0l);
}
}