Skip to content

Commit c20d122

Browse files
himash79himash79
authored
Initial commit
1 parent a6e8b67 commit c20d122

7 files changed

+315
-0
lines changed

‎project/project.iml

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
<?xml version="1.0" encoding="UTF-8"?>
2+
<module type="JAVA_MODULE" version="4">
3+
<component name="NewModuleRootManager" inherit-compiler-output="true">
4+
<exclude-output />
5+
<content url="file://$MODULE_DIR$">
6+
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
7+
</content>
8+
<orderEntry type="inheritedJdk" />
9+
<orderEntry type="sourceFolder" forTests="false" />
10+
</component>
11+
</module>

‎project/src/Main.java

+5
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
public class Main {
2+
public static void main(String[] args) {
3+
System.out.println("Hello world!");
4+
}
5+
}

‎project/src/lk/himash/Illustration_01.java

+97
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
1+
package lk.himash;
2+
3+
import jdk.incubator.concurrent.ScopedValue;
4+
5+
import java.util.List;
6+
import java.util.concurrent.Executors;
7+
8+
public class Illustration_01 {
9+
10+
// Scoped value example vs thread local
11+
12+
final static ThreadLocal<String> USER_LOCAL = new ThreadLocal<>();
13+
final static ScopedValue<String> USER_SCOPE = ScopedValue.newInstance();
14+
15+
16+
public static void main(String[] args) {
17+
var users = List.of(
18+
"Neo",
19+
"Trinity",
20+
"Morpheus",
21+
"Switch",
22+
"Dozer"
23+
);
24+
25+
var calculator = new Calculator();
26+
var worker = new UserWorker(calculator);
27+
28+
// now ExecutorService extends AutoCloseable
29+
try (var executor = Executors.newThreadPerTaskExecutor(Thread.ofVirtual().factory())) {
30+
System.out.println("Starting processing");
31+
for (var i = 0; i < 5; i++) {
32+
var user = users.get(i);
33+
34+
System.out.printf("Starting worker user %s%n", user);
35+
executor.submit(() -> {
36+
// ThreadLocal just set
37+
USER_LOCAL.set(user);
38+
39+
// with ScopedValue, we set the value and define the scope in which it will be available
40+
ScopedValue.where(USER_SCOPE, user)
41+
.run(worker::run);
42+
43+
var userLocal = USER_LOCAL.get();
44+
System.out.printf("User is still available in ThreadLocal: %s%n", userLocal);
45+
});
46+
}
47+
}
48+
49+
System.out.println("Processing ended");
50+
}
51+
}
52+
53+
class UserWorker implements Runnable {
54+
private Calculator calculator;
55+
56+
public UserWorker(Calculator calculator) {
57+
this.calculator = calculator;
58+
}
59+
60+
public void run() {
61+
System.out.printf("Getting user for calculation...%n");
62+
// both we retrieve the value in the same way
63+
var user = Illustration_01.USER_SCOPE.get();
64+
var userLocal = Illustration_01.USER_LOCAL.get();
65+
66+
System.out.printf("Users - ScopedValue: %s - ThreadLocal: %s%n", user, userLocal);
67+
if (!user.equals(userLocal)) {
68+
System.out.printf("Users from ScopedValue and ThreadLocal aren't the same%n", user);
69+
return;
70+
}
71+
// the first difference, in ThreadLocal we can change the value at any time
72+
Illustration_01.USER_LOCAL.set(userLocal + " -- was changed");
73+
74+
System.out.printf("User %s - calculating...%n", user);
75+
var answer = this.calculator.calculate();
76+
System.out.printf("User %s - answer: %d%n", user, answer);
77+
}
78+
}
79+
80+
class Calculator {
81+
public int calculate() {
82+
// now the ThreadLocal will see a different value
83+
// (could be change anywhere, it require us to look for the points that is changing it)
84+
var user = Illustration_01.USER_SCOPE.get();
85+
var userLocal = Illustration_01.USER_LOCAL.get();
86+
87+
System.out.printf("Users - ScopedValue: %s - ThreadLocal: %s%n", user, userLocal);
88+
// pretend to go to DB to sum the rows
89+
try {
90+
Thread.sleep(500);
91+
} catch (InterruptedException ex) {
92+
}
93+
return user.length();
94+
}
95+
96+
}
97+

‎project/src/lk/himash/Illustration_02.java

+59
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
package lk.himash;
2+
3+
public class Illustration_02 {
4+
5+
// Record pattern
6+
7+
public static void main(String[] args) {
8+
enhancedForLoop();
9+
10+
genericInferrenceTest();
11+
12+
recordPatternInEnhancedForLoopHeader();
13+
}
14+
15+
public static void enhancedForLoop() {
16+
var points = new Point[]{
17+
new Point(10, 10),
18+
new Point(20, 20),
19+
new Point(30, 30),
20+
new Point(20, 50),
21+
new Point(10, 60)
22+
};
23+
24+
// we can now deconstruct a record type in the enhanced for loop
25+
for (Point(int x, int y) : points) {
26+
System.out.printf("Drawing at x=%d and y=%d%n", x, y);
27+
}
28+
}
29+
30+
public static void genericInferrenceTest() {
31+
var point = new Point(42, 42);
32+
var decoratedPoint = new Decorator(new ColoredPoint(point, "RED"));
33+
var anotherDecorated = new Decorator(decoratedPoint);
34+
35+
// here we don't need to use `Decorator<Decorator<ColoredPoint>>(Decorator<ColoredPoint>(ColoredPoint cp))` like in JDK 19
36+
if (anotherDecorated instanceof Decorator(Decorator(ColoredPoint(Point(int x, int y), String color)))) {
37+
System.out.println("\nAren't you using too much decorator?");
38+
System.out.printf("x=%d, y=%d; color=%s%n%n", x, y, color);
39+
}
40+
}
41+
42+
static void recordPatternInEnhancedForLoopHeader() {
43+
var items = new ColoredPoint[]{new ColoredPoint(new Point(42, 42), "red")};
44+
45+
for (ColoredPoint(Point(var x, var y), String color) : items) {
46+
System.out.printf("Point [%d, %d] has color %s", x, y, color);
47+
}
48+
}
49+
}
50+
51+
record Point(int x, int y) {
52+
}
53+
54+
record ColoredPoint(Point p, String color) {
55+
}
56+
57+
record Decorator<T>(T t) {
58+
}
59+

‎project/src/lk/himash/Illustration_03.java

+57
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
package lk.himash;
2+
3+
import jdk.incubator.concurrent.ScopedValue;
4+
5+
public class Illustration_03 {
6+
7+
// Scope value Usage
8+
final static ScopedValue<String> MAIN_SCOPE = ScopedValue.newInstance();
9+
10+
public static void main(String[] args) {
11+
System.out.println("Starting scoped value");
12+
13+
// we can share a value from here
14+
ScopedValue.where(MAIN_SCOPE, "message from main")
15+
.run(() -> {
16+
var worker = new Worker();
17+
worker.execute();
18+
});
19+
System.out.println("main ending");
20+
}
21+
}
22+
23+
class Worker {
24+
final static ScopedValue<String> WORKER_SCOPE = ScopedValue.newInstance();
25+
26+
public void execute() {
27+
// accessing the value from the scope
28+
System.out.println("shared value from main: " + Illustration_03.MAIN_SCOPE.get());
29+
30+
// === Nested Scope ===
31+
// we can create a nested scope
32+
ScopedValue.where(WORKER_SCOPE, "message from worker")
33+
.run(() -> {
34+
// the outmost scope will still works
35+
var messageFromMain = Illustration_03.MAIN_SCOPE.get();
36+
var messageFromWorker = WORKER_SCOPE.get();
37+
System.out.println("shared value to inner scope from main: " + messageFromMain);
38+
System.out.println("shared value to inner scope from worker: " + messageFromWorker);
39+
});
40+
41+
// we cannot access it from outside its scope (NoSuchElementException)
42+
// var invalidAccess = WORKER_SCOPE.get();
43+
44+
// === Rebinded Scope Value ===
45+
// we can create a new scope that rebinds a new value to the created scope (when using the same variable)
46+
ScopedValue.where(Illustration_03.MAIN_SCOPE, "message from worker over main")
47+
.run(() -> {
48+
// the outmost scope will still works
49+
var rebindedMessage = Illustration_03.MAIN_SCOPE.get();
50+
System.out.println("shared value from shadowed scope: " + rebindedMessage);
51+
});
52+
53+
// but the original scope from main will still have its initial value (immutable)
54+
System.out.println("shared value from main after all scopes: " + Illustration_03.MAIN_SCOPE.get());
55+
}
56+
57+
}

‎project/src/lk/himash/Illustration_04.java

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
package lk.himash;
2+
3+
import jdk.incubator.concurrent.ScopedValue;
4+
5+
public class Illustration_04 {
6+
7+
// Scoped value usage with return value
8+
9+
final static ScopedValue<Integer> MAIN_SCOPE = ScopedValue.newInstance();
10+
11+
public static void main(String[] args) throws Exception {
12+
// we use `call` to run a scope and get it returned value
13+
var result = ScopedValue.where(MAIN_SCOPE, 42)
14+
.call(() -> { // throws Exception
15+
var calculator = new Calculator_02();
16+
return calculator.calculate();
17+
});
18+
System.out.println("Result from calculation: " + result);
19+
}
20+
}
21+
22+
class Calculator_02 {
23+
public int calculate() {
24+
var seed = Illustration_04.MAIN_SCOPE.get();
25+
return seed + 42;
26+
}
27+
28+
}

‎project/src/lk/himash/Illustration_05.java

+58
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
package lk.himash;
2+
3+
import jdk.incubator.concurrent.ScopedValue;
4+
import jdk.incubator.concurrent.StructuredTaskScope;
5+
6+
import java.util.concurrent.ExecutionException;
7+
import java.util.concurrent.Future;
8+
9+
public class Illustration_05 {
10+
11+
// Structured concurrency with scoped value
12+
13+
private final static ScopedValue<String> USER_ID = ScopedValue.newInstance();
14+
15+
public static void main(String[] args) {
16+
new Illustration_05().run();
17+
}
18+
19+
public void run() {
20+
try {
21+
var result = ScopedValue.where(USER_ID, "neo").call(this::parallelHandle);
22+
System.out.println(result);
23+
} catch (Exception ex) {
24+
ex.printStackTrace();
25+
}
26+
}
27+
28+
private String parallelHandle() throws InterruptedException, ExecutionException {
29+
// when we create a scope, the scoped values are captured
30+
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
31+
// the child scopes can use its parent's scoped value bindings
32+
Future<String> userName = scope.fork(this::findUserName);
33+
Future<String> answer = scope.fork(this::findPower);
34+
35+
scope.join();
36+
scope.throwIfFailed();
37+
38+
var userId = USER_ID.get();
39+
return "The real name of '%s' is '%s' and its power is %s".formatted(userId, userName.resultNow(), answer.resultNow());
40+
}
41+
}
42+
43+
private String findUserName() {
44+
var userId = USER_ID.get();
45+
System.out.println("Searching name for user ID: " + userId);
46+
return userId;
47+
}
48+
49+
private String findPower() {
50+
var userId = USER_ID.get();
51+
System.out.println("Calculating power for user ID: " + userId);
52+
try {
53+
Thread.sleep(3000);
54+
} catch (Exception ex) {}
55+
return "Over 9000";
56+
}
57+
58+
}

0 commit comments

Comments
 (0)