Skip to content

Commit f36e049

Browse files
LeonardoZLeonardoZ
committed
Using var to make code easier to read
1 parent bd13ade commit f36e049

29 files changed

+196
-181
lines changed

‎README.md

+6-6
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,12 @@ Concurrency Patterns and features found in Java, through multithreaded programmi
1919
* [ConcurrentHashMap](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/collections/UsingConcurrentCollections.java#L40)
2020
* [Blocking Queue](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/collections/UsingConcurrentCollections.java#L141)
2121
* [Executors](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java)
22-
* [Fixed Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L97)
23-
* [Cached Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L68)
24-
* [Single Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L54)
25-
* [Scheduled Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L127)
26-
* [Single Thread Scheduled Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L142)
27-
* [Work-Stealing Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L159)
22+
* [Fixed Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L94)
23+
* [Cached Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L65)
24+
* [Single Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L51)
25+
* [Scheduled Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L122)
26+
* [Single Thread Scheduled Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L139)
27+
* [Work-Stealing Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L156)
2828
* [Atomics](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/atomics/UsingAtomics.java)
2929
* [Futures](https://github.com/LeonardoZ/java-concurrency-patterns/tree/master/src/main/java/br/com/leonardoz/features/futures)
3030
* [FutureTask](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/futures/UsingFutureTasks.java)

‎src/main/java/br/com/leonardoz/features/atomics/UsingAtomics.java

+5-6
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
package br.com.leonardoz.features.atomics;
22

3-
import java.util.concurrent.ExecutorService;
43
import java.util.concurrent.Executors;
54
import java.util.concurrent.TimeUnit;
65
import java.util.concurrent.atomic.AtomicInteger;
@@ -47,13 +46,13 @@ public int get() {
4746
}
4847

4948
public static void main(String[] args) throws InterruptedException {
50-
AtomicCounter counter = new AtomicCounter();
51-
ExecutorService ctp = Executors.newCachedThreadPool();
49+
var counter = new AtomicCounter();
50+
var cachedThreadPool = Executors.newCachedThreadPool();
5251
for (int i = 0; i < 10_000; i++) {
53-
ctp.execute(() -> counter.increment());
52+
cachedThreadPool.execute(() -> counter.increment());
5453
}
55-
ctp.shutdown();
56-
ctp.awaitTermination(4000, TimeUnit.SECONDS);
54+
cachedThreadPool.shutdown();
55+
cachedThreadPool.awaitTermination(4000, TimeUnit.SECONDS);
5756
System.out.println("Result shound be 10000: Actual result is: " + counter.get());
5857
}
5958
}

‎src/main/java/br/com/leonardoz/features/collections/UsingConcurrentCollections.java

+20-22
Original file line numberDiff line numberDiff line change
@@ -2,10 +2,8 @@
22

33
import java.util.Random;
44
import java.util.UUID;
5-
import java.util.concurrent.BlockingQueue;
65
import java.util.concurrent.ConcurrentHashMap;
76
import java.util.concurrent.CopyOnWriteArrayList;
8-
import java.util.concurrent.ExecutorService;
97
import java.util.concurrent.Executors;
108
import java.util.concurrent.LinkedBlockingQueue;
119
import java.util.concurrent.TimeUnit;
@@ -38,10 +36,10 @@ public class UsingConcurrentCollections {
3836
* - Just a few Writers can modify it.
3937
*/
4038
public static void usingConcurrentHashMap() {
41-
ExecutorService executor = Executors.newCachedThreadPool();
4239
System.out.println("=== ConcurrentHashMap ===");
43-
Random random = new Random();
44-
ConcurrentHashMap<UUID, Integer> valuesPerUuid = new ConcurrentHashMap<>();
40+
var executor = Executors.newCachedThreadPool();
41+
var random = new Random();
42+
var valuesPerUuid = new ConcurrentHashMap<UUID, Integer>();
4543
// atomic operations
4644
valuesPerUuid.putIfAbsent(UUID.randomUUID(), random.nextInt(100));
4745

@@ -87,28 +85,28 @@ public static void usingConcurrentHashMap() {
8785
*
8886
*/
8987
public static void usingCopyOnWriteArrayList() {
90-
ExecutorService executor = Executors.newCachedThreadPool();
9188
System.out.println("=== CopyOnWriteArrayList ===");
92-
Random random = new Random();
89+
var executor = Executors.newCachedThreadPool();
90+
var random = new Random();
9391
// No ConcurrentModificationException
94-
CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
92+
var copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>();
9593

9694
for (int i = 0; i < 100; i++) {
9795
if (i % 8 == 0) {
9896
// write
9997
executor.execute(() -> {
100-
Integer value = random.nextInt(10);
98+
var value = random.nextInt(10);
10199
System.err.println("Added " + value);
102100
copyOnWriteArrayList.add(value);
103101
});
104102
} else {
105103
// read
106104
executor.execute(() -> {
107-
StringBuilder sb = new StringBuilder();
108-
for (Integer vv : copyOnWriteArrayList) {
109-
sb.append(vv + " ");
105+
var builder = new StringBuilder();
106+
for (var value : copyOnWriteArrayList) {
107+
builder.append(value + " ");
110108
}
111-
System.out.println("Reading " + sb.toString());
109+
System.out.println("Reading " + builder.toString());
112110
});
113111
}
114112
}
@@ -142,15 +140,15 @@ public static void usingBlockingQueue() {
142140
System.out.println("=== BlockingQueue ===");
143141

144142
// Bounded UUID queue
145-
BlockingQueue<UUID> uuidQueue = new LinkedBlockingQueue<>(10);
143+
var uuidQueue = new LinkedBlockingQueue<UUID>(10);
146144

147145
System.out.println("Queue will execute for 10s");
148146

149147
// Multiple consumers
150148
Runnable runConsumer = () -> {
151149
while (!Thread.currentThread().isInterrupted()) {
152150
try {
153-
UUID uuid = uuidQueue.take();
151+
var uuid = uuidQueue.take();
154152
System.out.println("Consumed: " + uuid + " by " + Thread.currentThread().getName());
155153

156154
} catch (InterruptedException e) {
@@ -161,9 +159,9 @@ public static void usingBlockingQueue() {
161159
}
162160
}
163161
};
164-
Thread consumer1 = new Thread(runConsumer);
162+
var consumer1 = new Thread(runConsumer);
165163
consumer1.start();
166-
Thread consumer2 = new Thread(runConsumer);
164+
var consumer2 = new Thread(runConsumer);
167165
consumer2.start();
168166

169167
// Producer Thread
@@ -184,11 +182,11 @@ public static void usingBlockingQueue() {
184182
};
185183

186184
// Multiple producers - Examples using simple threads this time.
187-
Thread producer1 = new Thread(runProducer);
185+
var producer1 = new Thread(runProducer);
188186
producer1.start();
189-
Thread producer2 = new Thread(runProducer);
187+
var producer2 = new Thread(runProducer);
190188
producer2.start();
191-
Thread producer3 = new Thread(runProducer);
189+
var producer3 = new Thread(runProducer);
192190
producer3.start();
193191

194192
try {
@@ -206,8 +204,8 @@ public static void usingBlockingQueue() {
206204
}
207205

208206
public static void main(String[] args) {
209-
// usingConcurrentHashMap();
210-
// usingCopyOnWriteArrayList();
207+
usingConcurrentHashMap();
208+
usingCopyOnWriteArrayList();
211209
usingBlockingQueue();
212210
}
213211

‎src/main/java/br/com/leonardoz/features/collections/UsingSynchronizedCollections.java

+5-6
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
package br.com.leonardoz.features.collections;
22

33
import java.util.Vector;
4-
import java.util.concurrent.ExecutorService;
54
import java.util.concurrent.Executors;
65
import java.util.concurrent.TimeUnit;
76

@@ -30,7 +29,7 @@ public class UsingSynchronizedCollections {
3029
*/
3130
public static void insertIfAbsent(Vector<Long> list, Long value) {
3231
synchronized (list) {
33-
boolean contains = list.contains(value);
32+
var contains = list.contains(value);
3433
if (!contains) {
3534
list.add(value);
3635
System.out.println("Value added: " + value);
@@ -43,21 +42,21 @@ public static void insertIfAbsent(Vector<Long> list, Long value) {
4342
* results
4443
*/
4544
public static void insertIfAbsentUnsafe(Vector<Long> list, Long value) {
46-
boolean contains = list.contains(value);
45+
var contains = list.contains(value);
4746
if (!contains) {
4847
list.add(value);
4948
System.out.println("Value added: " + value);
5049
}
5150
}
5251

5352
public static void main(String[] args) throws InterruptedException {
54-
ExecutorService executor = Executors.newCachedThreadPool();
53+
var executor = Executors.newCachedThreadPool();
5554
// Synchronized - Vector
56-
Vector<Long> vec = new Vector<>();
55+
var vector = new Vector<Long>();
5756

5857
Runnable insertIfAbsent = () -> {
5958
long millis = System.currentTimeMillis() / 1000;
60-
insertIfAbsent(vec, millis);
59+
insertIfAbsent(vector, millis);
6160
};
6261
for (int i = 0; i < 10001; i++) {
6362
executor.execute(insertIfAbsent);

‎src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java

+17-20
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,11 @@
11
package br.com.leonardoz.features.executors;
22

33
import java.util.LinkedList;
4-
import java.util.List;
54
import java.util.UUID;
65
import java.util.concurrent.Callable;
76
import java.util.concurrent.ExecutionException;
8-
import java.util.concurrent.ExecutorService;
97
import java.util.concurrent.Executors;
108
import java.util.concurrent.Future;
11-
import java.util.concurrent.ScheduledExecutorService;
129
import java.util.concurrent.TimeUnit;
1310

1411
/**
@@ -53,7 +50,7 @@ public class UsingExecutors {
5350

5451
public static void usingSingleThreadExecutor() {
5552
System.out.println("=== SingleThreadExecutor ===");
56-
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
53+
var singleThreadExecutor = Executors.newSingleThreadExecutor();
5754
singleThreadExecutor.execute(() -> System.out.println("Print this."));
5855
singleThreadExecutor.execute(() -> System.out.println("and this one to."));
5956
singleThreadExecutor.shutdown();
@@ -67,15 +64,15 @@ public static void usingSingleThreadExecutor() {
6764

6865
public static void usingCachedThreadPool() {
6966
System.out.println("=== CachedThreadPool ===");
70-
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
71-
List<Future<UUID>> uuids = new LinkedList<>();
67+
var cachedThreadPool = Executors.newCachedThreadPool();
68+
var uuids = new LinkedList<Future<UUID>>();
7269
for (int i = 0; i < 10; i++) {
73-
Future<UUID> submitted = cachedThreadPool.submit(() -> {
74-
UUID randomUUID = UUID.randomUUID();
70+
var submittedUUID = cachedThreadPool.submit(() -> {
71+
var randomUUID = UUID.randomUUID();
7572
System.out.println("UUID " + randomUUID + " from " + Thread.currentThread().getName());
7673
return randomUUID;
7774
});
78-
uuids.add(submitted);
75+
uuids.add(submittedUUID);
7976
}
8077
cachedThreadPool.execute(() -> uuids.forEach((f) -> {
8178
try {
@@ -96,11 +93,11 @@ public static void usingCachedThreadPool() {
9693

9794
public static void usingFixedThreadPool() {
9895
System.out.println("=== FixedThreadPool ===");
99-
ExecutorService fixedPool = Executors.newFixedThreadPool(4);
100-
List<Future<UUID>> uuids = new LinkedList<>();
96+
var fixedPool = Executors.newFixedThreadPool(4);
97+
var uuids = new LinkedList<Future<UUID>>();
10198
for (int i = 0; i < 20; i++) {
102-
Future<UUID> submitted = fixedPool.submit(() -> {
103-
UUID randomUUID = UUID.randomUUID();
99+
var submitted = fixedPool.submit(() -> {
100+
var randomUUID = UUID.randomUUID();
104101
System.out.println("UUID " + randomUUID + " from " + Thread.currentThread().getName());
105102
return randomUUID;
106103
});
@@ -124,7 +121,7 @@ public static void usingFixedThreadPool() {
124121

125122
public static void usingScheduledThreadPool() {
126123
System.out.println("=== ScheduledThreadPool ===");
127-
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
124+
var scheduledThreadPool = Executors.newScheduledThreadPool(4);
128125
scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
129126
scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("2) Print every 2s"), 0, 2, TimeUnit.SECONDS);
130127
scheduledThreadPool.scheduleWithFixedDelay(() -> System.out.println("3) Print every 2s delay"), 0, 2,
@@ -141,7 +138,7 @@ public static void usingScheduledThreadPool() {
141138

142139
public static void usingSingleTreadScheduledExecutor() {
143140
System.out.println("=== SingleThreadScheduledThreadPool ===");
144-
ScheduledExecutorService singleThreadScheduler = Executors.newSingleThreadScheduledExecutor();
141+
var singleThreadScheduler = Executors.newSingleThreadScheduledExecutor();
145142
singleThreadScheduler.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
146143
singleThreadScheduler.scheduleWithFixedDelay(() -> System.out.println("2) Print every 2s delay"), 0, 2,
147144
TimeUnit.SECONDS);
@@ -158,21 +155,21 @@ public static void usingSingleTreadScheduledExecutor() {
158155

159156
public static void usingWorkStealingThreadPool() {
160157
System.out.println("=== WorkStealingThreadPool ===");
161-
ExecutorService workStealingPool = Executors.newWorkStealingPool();
158+
var workStealingPool = Executors.newWorkStealingPool();
162159

163160
workStealingPool.execute(() -> System.out.println("Prints normally"));
164161

165162
Callable<UUID> generatesUUID = UUID::randomUUID;
166-
List<Callable<UUID>> severalUUIDsTasks = new LinkedList<>();
163+
var severalUUIDsTasks = new LinkedList<Callable<UUID>>();
167164
for (int i = 0; i < 20; i++) {
168165
severalUUIDsTasks.add(generatesUUID);
169166
}
170167

171168
try {
172-
List<Future<UUID>> futureUUIDs = workStealingPool.invokeAll(severalUUIDsTasks);
173-
for (Future<UUID> future : futureUUIDs) {
169+
var futureUUIDs = workStealingPool.invokeAll(severalUUIDsTasks);
170+
for (var future : futureUUIDs) {
174171
if (future.isDone()) {
175-
UUID uuid = future.get();
172+
var uuid = future.get();
176173
System.out.println("New UUID :" + uuid);
177174
}
178175
}

‎src/main/java/br/com/leonardoz/features/forkjoin/UsingForkJoinFramework.java

+13-14
Original file line numberDiff line numberDiff line change
@@ -96,8 +96,7 @@ public class UsingForkJoinFramework {
9696
*
9797
*/
9898
public ForkJoinPool getCommonPool() {
99-
ForkJoinPool commonPool = ForkJoinPool.commonPool();
100-
return commonPool;
99+
return ForkJoinPool.commonPool();
101100
}
102101

103102
/**
@@ -159,22 +158,22 @@ public RecSumTask(List<Integer> numbers) {
159158

160159
@Override
161160
protected BigInteger compute() {
162-
List<RecSumTask> subTasks = new LinkedList<>();
161+
var subTasks = new LinkedList<RecSumTask>();
163162
if (numbers.size() < DIVIDE_AT) {
164163
// directly
165-
BigInteger subSum = BigInteger.ZERO;
164+
var subSum = BigInteger.ZERO;
166165
for (Integer number : numbers) {
167166
subSum = subSum.add(BigInteger.valueOf(number));
168167
}
169168
return subSum;
170169
} else {
171170
// Divide to conquer
172-
int size = numbers.size();
173-
List<Integer> numbersLeft = numbers.subList(0, size / 2);
174-
List<Integer> numbersRight = numbers.subList(size / 2, size);
171+
var size = numbers.size();
172+
var numbersLeft = numbers.subList(0, size / 2);
173+
var numbersRight = numbers.subList(size / 2, size);
175174

176-
RecSumTask recSumLeft = new RecSumTask(numbersLeft);
177-
RecSumTask recSumRight = new RecSumTask(numbersRight);
175+
var recSumLeft = new RecSumTask(numbersLeft);
176+
var recSumRight = new RecSumTask(numbersRight);
178177

179178
subTasks.add(recSumRight);
180179
subTasks.add(recSumLeft);
@@ -184,8 +183,8 @@ protected BigInteger compute() {
184183
recSumRight.fork();
185184
}
186185

187-
BigInteger sum = BigInteger.ZERO;
188-
for (RecSumTask recSum : subTasks) {
186+
var sum = BigInteger.ZERO;
187+
for (var recSum : subTasks) {
189188
// Join Child Tasks
190189
sum = sum.add(recSum.join());
191190
}
@@ -195,14 +194,14 @@ protected BigInteger compute() {
195194

196195
public static void main(String[] args) {
197196
// prepares dataset for the example
198-
LinkedList<Integer> numbers = new LinkedList<>();
197+
var numbers = new LinkedList<Integer>();
199198
for (int i = 0; i < 500_000; i++) {
200199
numbers.add(i);
201200
}
202201

203202
// Usage
204-
ForkJoinPool commonPool = ForkJoinPool.commonPool();
205-
RecSumTask task = new RecSumTask(numbers);
203+
var commonPool = ForkJoinPool.commonPool();
204+
var task = new RecSumTask(numbers);
206205
BigInteger result = commonPool.invoke(task);
207206
System.out.println("Result is: " + result);
208207
System.out.println("\n\n");

0 commit comments

Comments
 (0)