repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter03/P68_PeriodOfTheDay/src/main/java/modern/challenge/DateConverters.java | Chapter03/P68_PeriodOfTheDay/src/main/java/modern/challenge/DateConverters.java | package modern.challenge;
import java.time.Instant;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Objects;
public final class DateConverters {
private DateConverters() {
throw new AssertionError("Cannot be instantiated");
}
public static String toDayPeriodV1(Date date, ZoneId zoneId) {
Objects.requireNonNull(date, "The provided date cannot be null");
Objects.requireNonNull(zoneId, "The provided zone id cannot be null");
LocalTime lt = date.toInstant().atZone(zoneId).toLocalTime();
LocalTime night = LocalTime.of(21, 0, 0);
LocalTime morning = LocalTime.of(6, 0, 0);
LocalTime afternoon = LocalTime.of(12, 0, 0);
LocalTime evening = LocalTime.of(18, 0, 0);
LocalTime almostMidnight = LocalTime.of(23, 59, 59);
LocalTime midnight = LocalTime.of(0, 0, 0);
if((lt.isAfter(night) && lt.isBefore(almostMidnight))
|| lt.isAfter(midnight) && (lt.isBefore(morning))) {
return "night";
} else if(lt.isAfter(morning) && lt.isBefore(afternoon)) {
return "morning";
} else if(lt.isAfter(afternoon) && lt.isBefore(evening)) {
return "afternoon";
} else if(lt.isAfter(evening) && lt.isBefore(night)) {
return "evening";
}
return "day";
}
public static String toDayPeriodV2(Date date, ZoneId zoneId) {
Objects.requireNonNull(date, "The provided date cannot be null");
Objects.requireNonNull(zoneId, "The provided zone id cannot be null");
ZonedDateTime zdt = date.toInstant().atZone(zoneId);
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MMM-dd'T'HH:mm:ss a Z");
System.out.println("Date-time to format as day period is: "
+ zdt.withZoneSameInstant(zoneId).format(formatter1));
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MMM-dd [B]");
return zdt.withZoneSameInstant(zoneId).format(formatter2);
}
public static void printToDayPeriod() {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh B");
for (int h = 0; h < 24; h++)
{
final OffsetDateTime odt
= Instant.now().atOffset(ZoneOffset.UTC).withHour(h);
System.out.println("Hour " + h
+ ": \"" + formatter.format(odt) + "\"");
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter03/P68_PeriodOfTheDay/src/main/java/modern/challenge/Main.java | Chapter03/P68_PeriodOfTheDay/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.ZoneId;
import java.util.Date;
public class Main {
public static void main(String[] args) {
System.out.println(ZoneId.getAvailableZoneIds());
System.out.println();
// Africa/Johannesburg
System.out.println("Good "
+ DateConverters.toDayPeriodV1(new Date(), ZoneId.of("Africa/Johannesburg"))
+ ", Africa/Johannesburg");
System.out.println("Africa/Johannesburg: "
+ DateConverters.toDayPeriodV2(new Date(), ZoneId.of("Africa/Johannesburg")));
System.out.println();
// Asia/Saigon
System.out.println("Good "
+ DateConverters.toDayPeriodV1(new Date(), ZoneId.of("Asia/Saigon"))
+ ", Asia/Saigon");
System.out.println("Asia/Saigon: "
+ DateConverters.toDayPeriodV2(new Date(), ZoneId.of("Asia/Saigon")));
System.out.println();
// Australia/Melbourne
System.out.println("Good "
+ DateConverters.toDayPeriodV1(new Date(), ZoneId.of("Australia/Melbourne"))
+ ", Australia/Melbourne");
System.out.println("Australia/Melbourne: "
+ DateConverters.toDayPeriodV2(new Date(), ZoneId.of("Australia/Melbourne")));
System.out.println();
// America/Resolute
System.out.println("Good "
+ DateConverters.toDayPeriodV1(new Date(), ZoneId.of("America/Resolute"))
+ ", America/Resolute");
System.out.println("America/Resolute: "
+ DateConverters.toDayPeriodV2(new Date(), ZoneId.of("America/Resolute")));
System.out.println();
// America/Argentina/Buenos_Aires
System.out.println("Good "
+ DateConverters.toDayPeriodV1(new Date(), ZoneId.of("America/Argentina/Buenos_Aires"))
+ ", America/Argentina/Buenos_Aires");
System.out.println("America/Argentina/Buenos_Aires: "
+ DateConverters.toDayPeriodV2(new Date(), ZoneId.of("America/Argentina/Buenos_Aires")));
// print hour-by-hour
System.out.println();
DateConverters.printToDayPeriod();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter03/P80_SystemUTCVsSystemDefaultZone/src/main/java/modern/challenge/Main.java | Chapter03/P80_SystemUTCVsSystemDefaultZone/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Clock;
import static java.time.Clock.system;
import java.time.LocalDateTime;
import java.time.ZoneId;
public class Main {
public static void main(String[] args) {
System.out.println(Clock.systemDefaultZone());
System.out.println(system(ZoneId.systemDefault()));
System.out.println(Clock.systemUTC());
System.out.println();
System.out.println(Clock.systemDefaultZone().instant());
System.out.println(system(ZoneId.systemDefault()).instant());
System.out.println(Clock.systemUTC().instant());
System.out.println();
System.out.println(LocalDateTime.now(Clock.systemUTC()));
System.out.println(LocalDateTime.now(Clock.systemDefaultZone()));
System.out.println(LocalDateTime.now(system(ZoneId.systemDefault())));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P240_VirtualThreadsHttpServer/src/main/java/modern/challenge/WebServerHandler.java | Chapter11/P240_VirtualThreadsHttpServer/src/main/java/modern/challenge/WebServerHandler.java | package modern.challenge;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;
public class WebServerHandler implements HttpHandler {
private final static Logger logger = Logger.getLogger(WebServerHandler.class.getName());
private final static int PERMITS = 20;
private final static Semaphore semaphore = new Semaphore(PERMITS);
private final static AtomicLong requestId = new AtomicLong();
private static final Callable<String> task = () -> {
String response = null;
try {
Thread.sleep(200);
response = "Request id_" + requestId.incrementAndGet();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return response;
};
private final boolean withLock;
public WebServerHandler(boolean withLock) {
this.withLock = withLock;
}
@Override
public void handle(HttpExchange exchange) throws IOException {
String response = null;
if (withLock) {
try {
semaphore.acquire();
} catch (InterruptedException e) { throw new RuntimeException(e); }
try {
response = task.call();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
semaphore.release();
}
} else {
try {
response = task.call();
} catch (Exception e) { throw new RuntimeException(e); }
}
logger.log(Level.INFO, "{0} | {1}", new Object[]{response,
Thread.currentThread()
});
exchange.sendResponseHeaders(
200, response == null ? 0 : response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response == null ? new byte[0] : response.getBytes());
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P240_VirtualThreadsHttpServer/src/main/java/modern/challenge/Main.java | Chapter11/P240_VirtualThreadsHttpServer/src/main/java/modern/challenge/Main.java | package modern.challenge;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final int MAX_NR_OF_THREADS = 200;
private static final int WEBSERVER_PORT = 8001;
public static void main(String[] args) throws IOException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
startWebServer(false, false);
}
private static void startWebServer(boolean virtual, boolean withLock) throws IOException {
HttpServer httpServer = HttpServer
.create(new InetSocketAddress(WEBSERVER_PORT), 0);
httpServer.createContext("/webserver", new WebServerHandler(withLock));
if (virtual) {
httpServer.setExecutor(
Executors.newVirtualThreadPerTaskExecutor());
} else {
httpServer.setExecutor(
Executors.newFixedThreadPool(MAX_NR_OF_THREADS));
}
httpServer.start();
logger.info(() -> " Server started on port " + WEBSERVER_PORT);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P239_IncVirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | Chapter11/P239_IncVirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | package modern.challenge;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
public final class AssemblyLine {
private AssemblyLine() {
throw new AssertionError("There is a single assembly line!");
}
private static final int MAX_NUMBER_OF_CONSUMERS = 50;
private static final int MAX_QUEUE_SIZE_ALLOWED = 5;
private static final int PRODUCERS = 3;
private static final int CONSUMERS = 2;
private static final int MAX_PROD_TIME_MS = 1 * 1000;
private static final int MAX_CONS_TIME_MS = 10 * 1000;
private static final int MONITOR_QUEUE_INITIAL_DELAY_MS = 5000;
private static final int MONITOR_QUEUE_RATE_MS = 3000;
private static final int EXTRA_TIME_MS = 4 * 1000;
private static final int SLOW_DOWN_PRODUCER_MS = 150 * 1000;
private static final int TIMEOUT_MS = MAX_PROD_TIME_MS + MAX_CONS_TIME_MS + 1000;
private static int extraProdTime;
private static final Logger logger = Logger.getLogger(AssemblyLine.class.getName());
private static final Random rnd = new Random();
private static final BlockingQueue<String> queue = new LinkedBlockingQueue<>();
private static volatile boolean runningProducer;
private static volatile boolean runningConsumer;
private static final Producer producer = new Producer();
private static final Consumer consumer = new Consumer();
private final static Semaphore producerService = new Semaphore(PRODUCERS);
private final static Semaphore consumerService = new Semaphore(CONSUMERS);
private static ScheduledExecutorService monitorService;
private static ScheduledExecutorService slowdownerService;
private static final AtomicInteger nrOfConsumers = new AtomicInteger(CONSUMERS);
private static final AtomicBoolean removeConsumer = new AtomicBoolean();
private static class Producer implements Runnable {
@Override
public void run() {
while (runningProducer) {
try {
String bulb = "bulb-" + rnd.nextInt(1000);
Thread.sleep(rnd.nextInt(MAX_PROD_TIME_MS) + extraProdTime);
queue.offer(bulb);
logger.info(() -> "Checked: " + bulb + " by producer: "
+ Thread.currentThread().toString());
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
// logger.severe(() -> "Exception: " + ex);
break;
}
}
}
}
private static class Consumer implements Runnable {
@Override
public void run() {
while (runningConsumer) {
try {
String bulb = queue.poll(MAX_PROD_TIME_MS + extraProdTime, TimeUnit.MILLISECONDS);
if (bulb != null) {
Thread.currentThread().sleep(rnd.nextInt(MAX_CONS_TIME_MS));
logger.info(() -> "Packed: " + bulb + " by consumer: "
+ Thread.currentThread().toString());
}
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
// logger.severe(() -> "Exception: " + ex);
break;
}
if (removeConsumer.get()) {
nrOfConsumers.decrementAndGet();
removeConsumer.set(false);
Thread.currentThread().interrupt();
}
}
}
}
public static void startAssemblyLine() throws InterruptedException {
if (runningProducer || runningConsumer) {
logger.info("Assembly line is already running ...");
return;
}
logger.info("\n\nStarting assembly line ...");
logger.info(() -> "Remaining bulbs from previous run: \n" + queue + "\n\n");
runningProducer = true;
for (int i = 0; i < PRODUCERS; i++) {
Thread.ofVirtual().start(() -> {
try {
producerService.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
producer.run();
} finally {
producerService.release();
}
});
}
runningConsumer = true;
for (int i = 0; i < CONSUMERS; i++) {
Thread.ofVirtual().start(() -> {
try {
consumerService.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
consumer.run();
} finally {
consumerService.release();
}
});
}
monitorQueueSize();
slowdownProducer();
}
private static void monitorQueueSize() {
monitorService = Executors.newSingleThreadScheduledExecutor();
monitorService.scheduleAtFixedRate(() -> {
if (queue.size() > MAX_QUEUE_SIZE_ALLOWED
&& nrOfConsumers.get() < MAX_NUMBER_OF_CONSUMERS) {
addNewConsumer();
} else {
if (nrOfConsumers.get() > CONSUMERS) {
removeConsumer();
}
}
logger.warning(() -> "### Bulbs in queue: " + queue.size()
+ " | Consumers waiting: " + consumerService.getQueueLength()
+ " | Consumer available permits: " + consumerService.availablePermits()
+ " | Running consumers: " + nrOfConsumers.get());
},
MONITOR_QUEUE_INITIAL_DELAY_MS, MONITOR_QUEUE_RATE_MS, TimeUnit.MILLISECONDS
);
}
public static void stopAssemblyLine() {
logger.info("Stopping assembly line ...");
runningProducer = false;
runningConsumer = false;
shutdownSchedulers();
}
private static void addNewConsumer() {
logger.warning("### Adding a new consumer ...");
if (consumerService.availablePermits() == 0) {
consumerService.release();
}
Thread.ofVirtual().start(() -> {
try {
consumerService.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
consumer.run();
} finally {
consumerService.release();
}
});
nrOfConsumers.incrementAndGet();
}
private static void removeConsumer() {
logger.warning("### Removing a consumer ...");
removeConsumer.set(true);
}
private static void slowdownProducer() {
slowdownerService = Executors.newSingleThreadScheduledExecutor();
slowdownerService.schedule(() -> {
logger.warning("### Slow down the producers ...");
extraProdTime = EXTRA_TIME_MS;
}, SLOW_DOWN_PRODUCER_MS, TimeUnit.MILLISECONDS);
}
private static boolean shutdownSchedulers() {
if (!runningProducer || !runningConsumer) {
return shutdownExecutor(monitorService) && shutdownExecutor(slowdownerService);
}
return false;
}
private static boolean shutdownExecutor(ExecutorService executor) {
executor.shutdown();
try {
if (!executor.awaitTermination(TIMEOUT_MS + extraProdTime, TimeUnit.MILLISECONDS)) {
executor.shutdownNow();
return executor.awaitTermination(TIMEOUT_MS + extraProdTime, TimeUnit.MILLISECONDS);
}
return true;
} catch (InterruptedException ex) {
executor.shutdownNow();
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
}
return false;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P239_IncVirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | Chapter11/P239_IncVirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
AssemblyLine.startAssemblyLine();
Thread.sleep(10 * 60 * 1000); // 10 minutes
AssemblyLine.stopAssemblyLine();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P231_IntroScopedValues2/src/main/java/modern/challenge/Main.java | Chapter11/P231_IntroScopedValues2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ThreadLocal<String> threadLocal
= ThreadLocal.<String>withInitial(() -> {
return "";
});
private static final ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
public static void sayHelloTL() {
logger.info(Thread.currentThread().toString());
logger.info(() -> "Hello " + threadLocal.get());
}
public static void sayGoodByeTL() {
logger.info(Thread.currentThread().toString());
logger.info(() -> "Good bye " + threadLocal.get());
}
public static void sayHelloSV() {
logger.info(Thread.currentThread().toString());
logger.info(() -> "Hello " + SCOPED_VALUE.orElse("you"));
}
public static void sayGoodByeSV() {
logger.info(Thread.currentThread().toString());
logger.info(() -> "Good bye " + SCOPED_VALUE.orElse("you"));
}
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
threadLocal.set("Mike");
sayHelloTL();
sayGoodByeTL();
ScopedValue.where(SCOPED_VALUE, "Mike").run(() -> sayHelloSV());
// ScopedValue.where(SCOPED_VALUE, "Mike").run(() -> sayGoodByeSV());
sayGoodByeSV();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P232_ScopedValueAndExecutorService/src/main/java/modern/challenge/Main.java | Chapter11/P232_ScopedValueAndExecutorService/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task = () -> {
logger.info(() -> Thread.currentThread().toString()
+ " | before sleep | " + (SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound"));
try {
Thread.sleep(Duration.ofSeconds(new Random().nextInt(5)));
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
}
logger.info(() -> Thread.currentThread().toString()
+ " | after sleep | " + (SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound"));
};
// Executors.newFixedThreadPool(10)
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10; i++) {
int copy_i = i;
executor.submit(() -> ScopedValue.where(SCOPED_VALUE, "Kaboooom-" + copy_i).run(task));
}
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P242_VirtualThreadsWaitNotify2/src/main/java/modern/challenge/Main.java | Chapter11/P242_VirtualThreadsWaitNotify2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Object object = new Object();
Thread wThread = Thread.ofVirtual().unstarted(() -> {
synchronized (object) {
try {
logger.info("Before calling wait()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
object.wait();
logger.info("After calling notify()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
} catch (InterruptedException e) {}
}
});
Thread nThread = Thread.ofVirtual().unstarted(() -> {
synchronized (object) {
logger.info(() -> Thread.currentThread() + " calls notify()");
object.notify();
}
});
nThread.start();
Thread.sleep(1000); // give time to 'nThread' to start
wThread.start();
Thread.sleep(1000); // give time to 'wThread' to start
logger.info("'wThread' current status");
logger.info(() -> wThread + " | " + wThread.getState());
wThread.join(); // waits indefinitely since notify() was missed
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/UserNotFoundException.java | Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/Main.java | Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
logger.info(buildTestingTeam().toString());
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
CompletableFuture<String> cfTester1 = fetchTester1();
CompletableFuture<String> cfTester2 = fetchTester2();
CompletableFuture<String> cfTester3 = fetchTester3();
CompletableFuture<Void> fetchTesters = CompletableFuture.allOf(
cfTester1, cfTester2, cfTester3);
fetchTesters.get();
TestingTeam team = new TestingTeam(
cfTester1.resultNow(), cfTester2.resultNow(), cfTester3.resultNow());
return team;
}
public static CompletableFuture<String> fetchTester1() {
return CompletableFuture.supplyAsync(() -> {
String tester1 = null;
try {
logger.info(Thread.currentThread().toString());
tester1 = fetchTester(1);
} catch (IOException | InterruptedException ex) { /* handle exceptions */ }
return tester1;
}, executor);
}
public static CompletableFuture<String> fetchTester2() {
return CompletableFuture.supplyAsync(() -> {
String tester2 = null;
try {
logger.info(Thread.currentThread().toString());
tester2 = fetchTester(2);
} catch (IOException | InterruptedException ex) { /* handle exceptions */ }
return tester2;
}, executor);
}
public static CompletableFuture<String> fetchTester3() {
return CompletableFuture.supplyAsync(() -> {
String tester3 = null;
try {
logger.info(Thread.currentThread().toString());
tester3 = fetchTester(3);
} catch (IOException | InterruptedException ex) { /* handle exceptions */ }
return tester3;
}, executor);
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/TestingTeam.java | Chapter11/P241_CompletableFutureAndVirtualThreads/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P225_SimpleVirtualThreadContinuations/src/main/java/modern/challenge/Main.java | Chapter11/P225_SimpleVirtualThreadContinuations/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
import java.util.stream.IntStream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
List<Thread> vtThreads = IntStream.range(0, 5)
.mapToObj(i -> Thread.ofVirtual().unstarted(() -> {
if (i == 0) { logger.info(Thread.currentThread().toString()); }
try { Thread.sleep(1000); } catch (InterruptedException ex) {}
if (i == 0) { logger.info(Thread.currentThread().toString()); }
})).toList();
vtThreads.forEach(Thread::start);
vtThreads.forEach(thread -> {
try { thread.join(); } catch (InterruptedException ex) {}
});
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P236_AvoidPinningViaLocking/src/main/java/modern/challenge/Main.java | Chapter11/P236_AvoidPinningViaLocking/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final int NUMBER_OF_TASKS = 25;
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task1 = () -> {
synchronized (Main.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException ex) { /* handle exception */ }
logger.info(() -> "Task-1 | " + Thread.currentThread().toString());
}
};
Lock lock = new ReentrantLock();
Runnable task2 = () -> {
lock.lock();
try {
Thread.sleep(1000);
logger.info(() -> "Task-2 | " + Thread.currentThread().toString());
} catch (InterruptedException ex) { /* handle exception */
} finally {
lock.unlock();
}
};
// using virtual threads that are pinned
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < NUMBER_OF_TASKS; i++) {
executor.submit(task1);
}
}
// using virtual threads that are not pinned
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < NUMBER_OF_TASKS; i++) {
executor.submit(task2);
}
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | package modern.challenge;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public final class PublicTransport {
public static List<PublicTransportOffer> busTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Bus", "Bus_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public bus-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> tramTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Tram", "Tram_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public tram-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> subwayTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Subway", "Subway_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public subway-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> trainTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Train", "Train_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public train-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
public final class Ridesharing {
public static RidesharingOffer carOneServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.25 + minutesToDest * 0.35;
return new RidesharingOffer("CarOne", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at CarOne for route: " + loc + " -> " + dest);
}
public static RidesharingOffer starCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.23 + minutesToDest * 0.37;
return new RidesharingOffer("StarCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at StarCar for route: " + loc + " -> " + dest);
}
public static RidesharingOffer topCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.26 + minutesToDest * 0.33;
return new RidesharingOffer("TopCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at TopCar for route: " + loc + " -> " + dest);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | package modern.challenge;
import java.time.LocalTime;
public record PublicTransportOffer(String transport,
String station, LocalTime goTime) {} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | package modern.challenge;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.StructuredTaskScope;
public class PublicTransportScope extends StructuredTaskScope<List<PublicTransportOffer>> {
private final List<List<PublicTransportOffer>> results = new CopyOnWriteArrayList<>();
private final List<Throwable> exceptions = new CopyOnWriteArrayList<>();
@Override
protected void handleComplete(Subtask<? extends List<PublicTransportOffer>> subtask) {
switch (subtask.state()) {
case SUCCESS ->
results.add(subtask.get());
case FAILED ->
exceptions.add(subtask.exception());
case UNAVAILABLE ->
throw new IllegalStateException("Subtask may still running ...");
}
}
public PublicTransportOffer recommendedPublicTransport() {
super.ensureOwnerAndJoined();
return results.stream()
.flatMap(t -> t.stream())
.min(Comparator.comparing(PublicTransportOffer::goTime))
.orElseThrow(this::wrappingExceptions);
}
private PublicTransportException wrappingExceptions() {
super.ensureOwnerAndJoined();
PublicTransportException exceptionWrapper
= new PublicTransportException("Public transport exception");
exceptions.forEach(exceptionWrapper::addSuppressed);
return exceptionWrapper;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | package modern.challenge;
public class PublicTransportException extends RuntimeException {
public PublicTransportException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/Main.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Comparator;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;
import java.util.logging.Logger;
import java.util.stream.Stream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
String loc = "124 NW Bobcat L, St. Robert"; // collected from user
String dest = "129 West 81st Street"; // collected from user
RidesharingOffer roffer = fetchRidesharingOffers(loc, dest);
PublicTransportOffer ptoffer = fetchPublicTransportOffers(loc, dest);
logger.info(roffer.toString());
logger.info(ptoffer.toString());
}
public static RidesharingOffer fetchRidesharingOffers(String loc, String dest)
throws InterruptedException {
try (StructuredTaskScope scope = new StructuredTaskScope<RidesharingOffer>()) {
Subtask<RidesharingOffer> carOneOffer
= scope.fork(() -> Ridesharing.carOneServer(loc, dest));
Subtask<RidesharingOffer> starCarOffer
= scope.fork(() -> Ridesharing.starCarServer(loc, dest));
Subtask<RidesharingOffer> topCarOffer
= scope.fork(() -> Ridesharing.topCarServer(loc, dest));
scope.join();
RidesharingOffer offer = Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.SUCCESS)
.<RidesharingOffer>mapMulti((s, c) -> {
c.accept((RidesharingOffer) s.get());
})
.min(Comparator.comparingDouble(RidesharingOffer::price))
.orElseThrow(() -> {
RidesharingException exceptionWrapper
= new RidesharingException("Ridesharing exception");
Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.FAILED)
.<Throwable>mapMulti((s, c) -> {
c.accept(s.exception());
}).forEach(exceptionWrapper::addSuppressed);
throw exceptionWrapper;
});
return offer;
}
}
public static PublicTransportOffer fetchPublicTransportOffers(String loc, String dest)
throws InterruptedException {
try (PublicTransportScope scope = new PublicTransportScope()) {
scope.fork(() -> PublicTransport.busTransportServer(loc, dest));
scope.fork(() -> PublicTransport.subwayTransportServer(loc, dest));
scope.fork(() -> PublicTransport.trainTransportServer(loc, dest));
scope.fork(() -> PublicTransport.tramTransportServer(loc, dest));
scope.join();
PublicTransportOffer offer = scope.recommendedPublicTransport();
return offer;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | package modern.challenge;
import java.time.Duration;
public record RidesharingOffer(String company, Duration minutesToYou,
Duration minutesToDest, double price) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | Chapter11/P227_ExtendStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | package modern.challenge;
public class RidesharingException extends RuntimeException {
public RidesharingException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P238_FixedVirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | Chapter11/P238_FixedVirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | package modern.challenge;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Semaphore;
import java.util.logging.Logger;
public final class AssemblyLine {
private AssemblyLine() {
throw new AssertionError("There is a single assembly line!");
}
private static final int PRODUCERS = 3;
private static final int CONSUMERS = 2;
private static final int MAX_PROD_TIME_MS = 2 * 1000;
private static final int MAX_CONS_TIME_MS = 2 * 1000;
private static final Logger logger = Logger.getLogger(AssemblyLine.class.getName());
private static final Random rnd = new Random();
private static final Queue<String> queue = new ConcurrentLinkedQueue<>();
private static volatile boolean runningProducer;
private static volatile boolean runningConsumer;
private static final Producer producer = new Producer();
private static final Consumer consumer = new Consumer();
private final static Semaphore producerService = new Semaphore(PRODUCERS);
private final static Semaphore consumerService = new Semaphore(CONSUMERS);
private static class Producer implements Runnable {
@Override
public void run() {
while (runningProducer) {
try {
String bulb = "bulb-" + rnd.nextInt(1000);
Thread.sleep(rnd.nextInt(MAX_PROD_TIME_MS));
queue.offer(bulb);
logger.info(() -> "Checked: " + bulb + " by producer: "
+ Thread.currentThread().toString());
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
break;
}
}
}
}
private static class Consumer implements Runnable {
@Override
public void run() {
while (runningConsumer) {
try {
String bulb = queue.poll();
if (bulb != null) {
Thread.sleep(rnd.nextInt(MAX_CONS_TIME_MS));
logger.info(() -> "Packed: " + bulb + " by consumer: "
+ Thread.currentThread().toString());
}
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
break;
}
}
}
}
public static void startAssemblyLine() throws InterruptedException {
if (runningProducer || runningConsumer) {
logger.info("Assembly line is already running ...");
return;
}
logger.info("\n\nStarting assembly line ...");
logger.info(() -> "Remaining bulbs from previous run: \n" + queue + "\n\n");
runningProducer = true;
for (int i = 0; i < PRODUCERS; i++) {
Thread.ofVirtual().start(() -> {
try {
producerService.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
producer.run();
} finally {
producerService.release();
}
});
}
runningConsumer = true;
for (int i = 0; i < CONSUMERS; i++) {
Thread.ofVirtual().start(() -> {
try {
consumerService.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
consumer.run();
} finally {
consumerService.release();
}
});
}
}
public static void stopAssemblyLine() {
logger.info("Stopping assembly line ...");
runningProducer = false;
runningConsumer = false;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P238_FixedVirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | Chapter11/P238_FixedVirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
AssemblyLine.startAssemblyLine();
Thread.sleep(60 * 100);
AssemblyLine.stopAssemblyLine();
Thread.sleep(2000);
System.out.println("\nStarting assembly line again ...");
AssemblyLine.startAssemblyLine();
Thread.sleep(60 * 100);
AssemblyLine.stopAssemblyLine();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P231_IntroScopedValues1/src/main/java/modern/challenge/Main.java | Chapter11/P231_IntroScopedValues1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.lang.ScopedValue.Carrier;
import java.util.concurrent.Callable;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable taskr = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound");
};
Callable<Boolean> taskc = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound");
return true;
};
logger.info("------------------------");
logger.info("ScopedValue and Runnable");
logger.info("------------------------");
taskr.run();
ScopedValue.where(SCOPED_VALUE, "Kaboooom!").run(taskr);
ScopedValue.runWhere(SCOPED_VALUE, "Kaboooom!", taskr);
Carrier cr = ScopedValue.where(SCOPED_VALUE, "Kaboooom!");
cr.run(taskr);
taskr.run();
logger.info("------------------------");
logger.info("ScopedValue and Callable");
logger.info("------------------------");
taskc.call();
ScopedValue.where(SCOPED_VALUE, "Kaboooom-1!").call(taskc);
ScopedValue.callWhere(SCOPED_VALUE, "Kaboooom-2!", taskc);
Carrier cc = ScopedValue.where(SCOPED_VALUE, "Kaboooom-3!");
cc.call(taskc);
taskc.call();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransport.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransport.java | package modern.challenge;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public final class PublicTransport {
public static List<PublicTransportOffer> busTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Bus", "Bus_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public bus-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> tramTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Tram", "Tram_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public tram-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> subwayTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Subway", "Subway_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public subway-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> trainTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Train", "Train_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public train-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/TravelOffer.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/TravelOffer.java | package modern.challenge;
public record TravelOffer(RidesharingOffer ridesharingOffer, PublicTransportOffer publicTransportOffer) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Ridesharing.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Ridesharing.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
public final class Ridesharing {
public static RidesharingOffer carOneServer(String loc, String dest) throws InterruptedException {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
Thread.sleep(100); // simulating a delay
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.25 + minutesToDest * 0.35;
return new RidesharingOffer("CarOne", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at CarOne for route: " + loc + " -> " + dest);
}
public static RidesharingOffer starCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.23 + minutesToDest * 0.37;
return new RidesharingOffer("StarCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at StarCar for route: " + loc + " -> " + dest);
}
public static RidesharingOffer topCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.26 + minutesToDest * 0.33;
return new RidesharingOffer("TopCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at TopCar for route: " + loc + " -> " + dest);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportOffer.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportOffer.java | package modern.challenge;
import java.time.LocalTime;
public record PublicTransportOffer(String transport,
String station, LocalTime goTime) implements Travel {} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportScope.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportScope.java | package modern.challenge;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.StructuredTaskScope.Subtask;
import java.util.concurrent.StructuredTaskScope;
public class PublicTransportScope extends StructuredTaskScope<List<PublicTransportOffer>> {
private final List<List<PublicTransportOffer>> results = new CopyOnWriteArrayList<>();
private final List<Throwable> exceptions = new CopyOnWriteArrayList<>();
protected void handleComplete(
Subtask<? extends List<PublicTransportOffer>> subtask) {
switch (subtask.state()) {
case SUCCESS ->
results.add(subtask.get());
case FAILED ->
exceptions.add(subtask.exception());
case UNAVAILABLE ->
throw new IllegalStateException("Subtask may still running ...");
}
}
public PublicTransportOffer recommendedPublicTransport() {
super.ensureOwnerAndJoined();
return results.stream()
.flatMap(t -> t.stream())
.min(Comparator.comparing(PublicTransportOffer::goTime))
.orElseThrow(this::wrappingExceptions);
}
private PublicTransportException wrappingExceptions() {
super.ensureOwnerAndJoined();
PublicTransportException exceptionWrapper
= new PublicTransportException("Public transport exception");
exceptions.forEach(exceptionWrapper::addSuppressed);
return exceptionWrapper;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/TravelScope.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/TravelScope.java | package modern.challenge;
import java.util.concurrent.TimeoutException;
import java.util.logging.Logger;
import java.util.concurrent.StructuredTaskScope;
public class TravelScope extends StructuredTaskScope<Travel> {
private static final Logger logger = Logger.getLogger(TravelScope.class.getName());
private volatile RidesharingOffer ridesharingOffer;
private volatile PublicTransportOffer publicTransportOffer;
private volatile RidesharingException ridesharingException;
private volatile PublicTransportException publicTransportException;
private volatile TimeoutException timeoutException;
@Override
protected void handleComplete(
Subtask<? extends Travel> subtask) {
switch (subtask.state()) {
case SUCCESS -> {
switch (subtask.get()) {
case RidesharingOffer ro ->
this.ridesharingOffer = ro;
case PublicTransportOffer pto ->
this.publicTransportOffer = pto;
}
}
case FAILED -> {
switch (subtask.exception()) {
case RidesharingException re ->
this.ridesharingException = re;
case PublicTransportException pte ->
this.publicTransportException = pte;
case TimeoutException te ->
this.timeoutException = te;
case Throwable t ->
throw new RuntimeException(t);
}
}
case UNAVAILABLE ->
throw new IllegalStateException("Subtask may still running ...");
}
}
public TravelOffer recommendedTravelOffer() {
super.ensureOwnerAndJoined();
if (timeoutException != null) {
logger.warning("Some of the called services did not respond in time");
}
return new TravelOffer(ridesharingOffer, publicTransportOffer);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportException.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/PublicTransportException.java | package modern.challenge;
public class PublicTransportException extends RuntimeException {
public PublicTransportException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Travel.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Travel.java | package modern.challenge;
public sealed interface Travel
permits RidesharingOffer, PublicTransportOffer {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Main.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Instant;
import java.util.Comparator;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import java.util.logging.Logger;
import java.util.stream.Stream;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
String loc = "124 NW Bobcat L, St. Robert"; // collected from user
String dest = "129 West 81st Street"; // collected from user
TravelOffer toffer = fetchTravelOffers(loc, dest);
logger.info(toffer.toString());
}
public static TravelOffer fetchTravelOffers(String loc, String dest)
throws InterruptedException {
try (TravelScope scope = new TravelScope()) {
scope.fork(() -> fetchRidesharingOffers(loc, dest));
scope.fork(() -> fetchPublicTransportOffers(loc, dest));
scope.join();
return scope.recommendedTravelOffer();
}
}
public static RidesharingOffer fetchRidesharingOffers(String loc, String dest)
throws InterruptedException, TimeoutException {
try (StructuredTaskScope scope = new StructuredTaskScope<RidesharingOffer>()) {
Subtask<RidesharingOffer> carOneOffer
= scope.fork(() -> Ridesharing.carOneServer(loc, dest));
Subtask<RidesharingOffer> starCarOffer
= scope.fork(() -> Ridesharing.starCarServer(loc, dest));
Subtask<RidesharingOffer> topCarOffer
= scope.fork(() -> Ridesharing.topCarServer(loc, dest));
scope.joinUntil(Instant.now().plusMillis(10));
RidesharingOffer offer = Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.SUCCESS)
.<RidesharingOffer>mapMulti((s, c) -> {
c.accept((RidesharingOffer) s.get());
})
.min(Comparator.comparingDouble(RidesharingOffer::price))
.orElseThrow(() -> {
RidesharingException exceptionWrapper
= new RidesharingException("Ridesharing exception");
Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.FAILED)
.<Throwable>mapMulti((s, c) -> {
c.accept(s.exception());
}).forEach(exceptionWrapper::addSuppressed);
throw exceptionWrapper;
});
return offer;
}
}
public static PublicTransportOffer fetchPublicTransportOffers(String loc, String dest)
throws InterruptedException {
try (PublicTransportScope scope = new PublicTransportScope()) {
scope.fork(() -> PublicTransport.busTransportServer(loc, dest));
scope.fork(() -> PublicTransport.subwayTransportServer(loc, dest));
scope.fork(() -> PublicTransport.trainTransportServer(loc, dest));
scope.fork(() -> PublicTransport.tramTransportServer(loc, dest));
scope.join();
PublicTransportOffer offer = scope.recommendedPublicTransport();
return offer;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/RidesharingOffer.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/RidesharingOffer.java | package modern.challenge;
import java.time.Duration;
public record RidesharingOffer(String company, Duration minutesToYou,
Duration minutesToDest, double price) implements Travel {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/RidesharingException.java | Chapter11/P229_AssembleStructuredTaskScopeTimeout/src/main/java/modern/challenge/RidesharingException.java | package modern.challenge;
public class RidesharingException extends RuntimeException {
public RidesharingException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P242_VirtualThreadsWaitNotify1/src/main/java/modern/challenge/Main.java | Chapter11/P242_VirtualThreadsWaitNotify1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Object object = new Object();
Thread wThread = Thread.ofVirtual().unstarted(() -> {
synchronized (object) {
try {
logger.info("Before calling wait()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
object.wait();
logger.info("After calling notify()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
} catch (InterruptedException e) {}
}
});
Thread nThread = Thread.ofVirtual().unstarted(() -> {
synchronized (object) {
logger.info(() -> Thread.currentThread() + " calls notify()");
object.notify();
}
});
wThread.start();
Thread.sleep(1000); // give time to 'wThread' to start
logger.info("'wThread' current status");
logger.info(() -> wThread + " | " + wThread.getState());
nThread.start();
Thread.sleep(1000); // give time to 'nThread' to start
logger.info("After executing 'wThread'");
logger.info(() -> wThread + " | " + wThread.getState());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | package modern.challenge;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public final class PublicTransport {
public static List<PublicTransportOffer> busTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Bus", "Bus_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public bus-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> tramTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Tram", "Tram_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public tram-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> subwayTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Subway", "Subway_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public subway-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
public static List<PublicTransportOffer> trainTransportServer(String loc, String dest) {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Train", "Train_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public train-transport is available for route: " + loc + " -> " + dest);
}
return listOfOffers;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/TravelOffer.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/TravelOffer.java | package modern.challenge;
public record TravelOffer(RidesharingOffer ridesharingOffer, PublicTransportOffer publicTransportOffer) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
public final class Ridesharing {
public static RidesharingOffer carOneServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.25 + minutesToDest * 0.35;
return new RidesharingOffer("CarOne", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at CarOne for route: " + loc + " -> " + dest);
}
public static RidesharingOffer starCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.23 + minutesToDest * 0.37;
return new RidesharingOffer("StarCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at StarCar for route: " + loc + " -> " + dest);
}
public static RidesharingOffer topCarServer(String loc, String dest) {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if(makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.26 + minutesToDest * 0.33;
return new RidesharingOffer("TopCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at TopCar for route: " + loc + " -> " + dest);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | package modern.challenge;
import java.time.LocalTime;
public record PublicTransportOffer(String transport,
String station, LocalTime goTime) implements Travel {} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | package modern.challenge;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.StructuredTaskScope;
public class PublicTransportScope extends StructuredTaskScope<List<PublicTransportOffer>> {
private final List<List<PublicTransportOffer>> results = new CopyOnWriteArrayList<>();
private final List<Throwable> exceptions = new CopyOnWriteArrayList<>();
@Override
protected void handleComplete(Subtask<? extends List<PublicTransportOffer>> subtask) {
switch (subtask.state()) {
case SUCCESS ->
results.add(subtask.get());
case FAILED ->
exceptions.add(subtask.exception());
case UNAVAILABLE ->
throw new IllegalStateException("Subtask may still running ...");
}
}
public PublicTransportOffer recommendedPublicTransport() {
super.ensureOwnerAndJoined();
return results.stream()
.flatMap(t -> t.stream())
.min(Comparator.comparing(PublicTransportOffer::goTime))
.orElseThrow(this::wrappingExceptions);
}
private PublicTransportException wrappingExceptions() {
super.ensureOwnerAndJoined();
PublicTransportException exceptionWrapper
= new PublicTransportException("Public transport exception");
exceptions.forEach(exceptionWrapper::addSuppressed);
return exceptionWrapper;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/TravelScope.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/TravelScope.java | package modern.challenge;
import java.util.concurrent.StructuredTaskScope;
public class TravelScope extends StructuredTaskScope<Travel> {
private volatile RidesharingOffer ridesharingOffer;
private volatile PublicTransportOffer publicTransportOffer;
private volatile RidesharingException ridesharingException;
private volatile PublicTransportException publicTransportException;
@Override
protected void handleComplete(Subtask<? extends Travel> subtask) {
switch (subtask.state()) {
case SUCCESS -> {
switch (subtask.get()) {
case RidesharingOffer ro ->
this.ridesharingOffer = ro;
case PublicTransportOffer pto ->
this.publicTransportOffer = pto;
}
}
case FAILED -> {
switch (subtask.exception()) {
case RidesharingException re ->
this.ridesharingException = re;
case PublicTransportException pte ->
this.publicTransportException = pte;
case Throwable t ->
throw new RuntimeException(t);
}
}
case UNAVAILABLE ->
throw new IllegalStateException("Subtask may still running ...");
}
}
public TravelOffer recommendedTravelOffer() {
super.ensureOwnerAndJoined();
return new TravelOffer(ridesharingOffer, publicTransportOffer);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | package modern.challenge;
public class PublicTransportException extends RuntimeException {
public PublicTransportException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Travel.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Travel.java | package modern.challenge;
public sealed interface Travel
permits RidesharingOffer, PublicTransportOffer {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Main.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Comparator;
import java.util.logging.Logger;
import java.util.stream.Stream;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;
@SuppressWarnings("unchecked")
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
String loc = "124 NW Bobcat L, St. Robert"; // collected from user
String dest = "129 West 81st Street"; // collected from user
TravelOffer toffer = fetchTravelOffers(loc, dest);
logger.info(toffer.toString());
}
public static TravelOffer fetchTravelOffers(String loc, String dest)
throws InterruptedException {
try (TravelScope scope = new TravelScope()) {
scope.fork(() -> fetchRidesharingOffers(loc, dest));
scope.fork(() -> fetchPublicTransportOffers(loc, dest));
scope.join();
return scope.recommendedTravelOffer();
}
}
public static RidesharingOffer fetchRidesharingOffers(String loc, String dest)
throws InterruptedException {
try (StructuredTaskScope scope = new StructuredTaskScope<RidesharingOffer>()) {
Subtask<RidesharingOffer> carOneOffer
= scope.fork(() -> Ridesharing.carOneServer(loc, dest));
Subtask<RidesharingOffer> starCarOffer
= scope.fork(() -> Ridesharing.starCarServer(loc, dest));
Subtask<RidesharingOffer> topCarOffer
= scope.fork(() -> Ridesharing.topCarServer(loc, dest));
scope.join();
RidesharingOffer offer = Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.SUCCESS)
.<RidesharingOffer>mapMulti((s, c) -> {
c.accept((RidesharingOffer) s.get());
})
.min(Comparator.comparingDouble(RidesharingOffer::price))
.orElseThrow(() -> {
RidesharingException exceptionWrapper
= new RidesharingException("Ridesharing exception");
Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.FAILED)
.<Throwable>mapMulti((s, c) -> {
c.accept(s.exception());
}).forEach(exceptionWrapper::addSuppressed);
throw exceptionWrapper;
});
return offer;
}
}
public static PublicTransportOffer fetchPublicTransportOffers(String loc, String dest)
throws InterruptedException {
try (PublicTransportScope scope = new PublicTransportScope()) {
scope.fork(() -> PublicTransport.busTransportServer(loc, dest));
scope.fork(() -> PublicTransport.subwayTransportServer(loc, dest));
scope.fork(() -> PublicTransport.trainTransportServer(loc, dest));
scope.fork(() -> PublicTransport.tramTransportServer(loc, dest));
scope.join();
PublicTransportOffer offer = scope.recommendedPublicTransport();
return offer;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | package modern.challenge;
import java.time.Duration;
public record RidesharingOffer(String company, Duration minutesToYou,
Duration minutesToDest, double price) implements Travel {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | Chapter11/P228_AssembleStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | package modern.challenge;
public class RidesharingException extends RuntimeException {
public RidesharingException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P235_SemaphoreVsExecutor/src/main/java/modern/challenge/Main.java | Chapter11/P235_SemaphoreVsExecutor/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final int NUMBER_OF_TASKS = 15;
private static final int NUMBER_OF_THREADS = 3;
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task = () -> {
try {
Thread.sleep(5000);
} catch (InterruptedException ex) { /* handle exception */ }
logger.info(Thread.currentThread().toString());
};
// using cached platform threads
try (ExecutorService executor = Executors.newFixedThreadPool(NUMBER_OF_THREADS)) {
for (int i = 0; i < NUMBER_OF_TASKS; i++) {
executor.submit(task);
}
}
// using virtual threads and Semaphore
Semaphore semaphore = new Semaphore(NUMBER_OF_THREADS);
Thread vt = Thread.currentThread();
for (int i = 0; i < NUMBER_OF_TASKS; i++) {
vt = Thread.ofVirtual().start(() -> {
try {
semaphore.acquire();
} catch (InterruptedException ex) { /* handle exception */ }
try {
task.run();
} finally {
semaphore.release();
}
});
}
vt.join();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P230_VirtualThreadAndThreadLocal/src/main/java/modern/challenge/Main.java | Chapter11/P230_VirtualThreadAndThreadLocal/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ThreadLocal<StringBuilder> threadLocal
= ThreadLocal.<StringBuilder>withInitial(() -> {
return new StringBuilder("Nothing here ...");
});
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task = () -> {
threadLocal.set(new StringBuilder(Thread.currentThread().toString()));
logger.info(() -> " before sleep -> " + Thread.currentThread().toString()
+ " [" + threadLocal.get() + "]");
try {
Thread.sleep(Duration.ofSeconds(new Random().nextInt(5)));
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
}
logger.info(() -> " after sleep -> " + Thread.currentThread().toString()
+ " [" + threadLocal.get() + "]");
threadLocal.remove();
};
// Executors.newFixedThreadPool(10)
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10; i++) {
executor.submit(task);
}
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransport.java | package modern.challenge;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import static modern.challenge.Main.DEST;
import static modern.challenge.Main.LOC;
import static modern.challenge.Main.PUBLIC_TRANSPORT_TICKET;
public final class PublicTransport {
public static List<PublicTransportOffer> busTransportServer() {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer && PUBLIC_TRANSPORT_TICKET.isBound() && PUBLIC_TRANSPORT_TICKET.get()) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Bus", "Bus_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public bus-transport is available for route: "
+ LOC.get() + " -> " + DEST.get());
}
return listOfOffers;
}
public static List<PublicTransportOffer> tramTransportServer() {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer && PUBLIC_TRANSPORT_TICKET.isBound() && PUBLIC_TRANSPORT_TICKET.get()) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Tram", "Tram_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public tram-transport is available for route: "
+ LOC.get() + " -> " + DEST.get());
}
return listOfOffers;
}
public static List<PublicTransportOffer> subwayTransportServer() {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer && PUBLIC_TRANSPORT_TICKET.isBound() && PUBLIC_TRANSPORT_TICKET.get()) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Subway", "Subway_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public subway-transport is available for route: "
+ LOC.get() + " -> " + DEST.get());
}
return listOfOffers;
}
public static List<PublicTransportOffer> trainTransportServer() {
List<PublicTransportOffer> listOfOffers = new ArrayList<>();
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer && PUBLIC_TRANSPORT_TICKET.isBound() && PUBLIC_TRANSPORT_TICKET.get()) {
for (int i = 0; i < rnd.nextInt(10); i++) {
LocalTime goTime = LocalTime.now()
.plusHours(rnd.nextInt(0, 4)).plusMinutes(rnd.nextInt(0, 61));
listOfOffers.add(new PublicTransportOffer("Train", "Train_station_" + i, goTime));
}
}
if (listOfOffers.isEmpty()) {
throw new RidesharingException("No public train-transport is available for route: "
+ LOC.get() + " -> " + DEST.get());
}
return listOfOffers;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/TravelOffer.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/TravelOffer.java | package modern.challenge;
public record TravelOffer(RidesharingOffer ridesharingOffer, PublicTransportOffer publicTransportOffer) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Ridesharing.java | package modern.challenge;
import java.time.Duration;
import java.util.Random;
import java.util.logging.Logger;
import static modern.challenge.Main.CAR_ONE_DISCOUNT;
import static modern.challenge.Main.DEST;
import static modern.challenge.Main.LOC;
import static modern.challenge.Main.USER;
public final class Ridesharing {
private static final Logger logger = Logger.getLogger(Ridesharing.class.getName());
public static RidesharingOffer carOneServer() {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.25 + minutesToDest * 0.35;
if (CAR_ONE_DISCOUNT.isBound()) {
logger.info(() -> "Congrats " + USER.get()
+ "! You have a discount of " + CAR_ONE_DISCOUNT.orElse(0.0));
price = price - CAR_ONE_DISCOUNT.orElse(0.0);
}
return new RidesharingOffer("CarOne", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at CarOne for route: "
+ LOC.get() + " -> " + DEST.get());
}
public static RidesharingOffer starCarServer() {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.23 + minutesToDest * 0.37;
return new RidesharingOffer("StarCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at StarCar for route: "
+ LOC.get() + " -> " + DEST.get());
}
public static RidesharingOffer topCarServer() {
Random rnd = new Random();
boolean makeAnOffer = rnd.nextBoolean();
if (makeAnOffer) {
int minutesToYou = rnd.nextInt(10);
int minutesToDest = rnd.nextInt(5, 50);
double price = minutesToYou * 0.26 + minutesToDest * 0.33;
return new RidesharingOffer("TopCar", Duration.ofMinutes(minutesToYou),
Duration.ofMinutes(minutesToDest), price);
}
throw new RidesharingException("No drivers are available at TopCar for route: "
+ LOC.get() + " -> " + DEST.get());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportOffer.java | package modern.challenge;
import java.time.LocalTime;
public record PublicTransportOffer(String transport,
String station, LocalTime goTime) implements Travel {} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportScope.java | package modern.challenge;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.StructuredTaskScope;
public class PublicTransportScope extends StructuredTaskScope<List<PublicTransportOffer>> {
private final List<List<PublicTransportOffer>> results = new CopyOnWriteArrayList<>();
private final List<Throwable> exceptions = new CopyOnWriteArrayList<>();
@Override
protected void handleComplete(Subtask<? extends List<PublicTransportOffer>> subtask) {
switch (subtask.state()) {
case SUCCESS ->
results.add(subtask.get());
case FAILED ->
exceptions.add(subtask.exception());
case UNAVAILABLE ->
throw new IllegalStateException(
"Subtask may still running ...");
}
}
public PublicTransportOffer recommendedPublicTransport() {
super.ensureOwnerAndJoined();
return results.stream()
.flatMap(t -> t.stream())
.min(Comparator.comparing(PublicTransportOffer::goTime))
.orElseThrow(this::wrappingExceptions);
}
private PublicTransportException wrappingExceptions() {
super.ensureOwnerAndJoined();
PublicTransportException exceptionWrapper = new PublicTransportException("Public transport exception");
exceptions.forEach(exceptionWrapper::addSuppressed);
return exceptionWrapper;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/TravelScope.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/TravelScope.java | package modern.challenge;
import java.util.concurrent.StructuredTaskScope;
public class TravelScope extends StructuredTaskScope<Travel> {
private volatile RidesharingOffer ridesharingOffer;
private volatile PublicTransportOffer publicTransportOffer;
private volatile RidesharingException ridesharingException;
private volatile PublicTransportException publicTransportException;
@Override
protected void handleComplete(Subtask<? extends Travel> subtask) {
switch (subtask.state()) {
case SUCCESS -> {
switch (subtask.get()) {
case RidesharingOffer ro ->
this.ridesharingOffer = ro;
case PublicTransportOffer pto ->
this.publicTransportOffer = pto;
}
}
case FAILED -> {
switch (subtask.exception()) {
case RidesharingException re ->
this.ridesharingException = re;
case PublicTransportException pte ->
this.publicTransportException = pte;
case Throwable t ->
throw new RuntimeException(t);
}
}
case UNAVAILABLE ->
throw new IllegalStateException(
"Subtask may still running ...");
}
}
public TravelOffer recommendedTravelOffer() {
super.ensureOwnerAndJoined();
return new TravelOffer(ridesharingOffer, publicTransportOffer);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/PublicTransportException.java | package modern.challenge;
public class PublicTransportException extends RuntimeException {
public PublicTransportException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Travel.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Travel.java | package modern.challenge;
public sealed interface Travel
permits RidesharingOffer, PublicTransportOffer {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Main.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Comparator;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;
import java.util.logging.Logger;
import java.util.stream.Stream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static final ScopedValue<String> USER = ScopedValue.newInstance();
public static final ScopedValue<String> LOC = ScopedValue.newInstance();
public static final ScopedValue<String> DEST = ScopedValue.newInstance();
public static final ScopedValue<Double> CAR_ONE_DISCOUNT = ScopedValue.newInstance();
public static final ScopedValue<Boolean> PUBLIC_TRANSPORT_TICKET = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
String user = "marcelo1978"; // login user
String loc = "124 NW Bobcat L, St. Robert"; // collected from user
String dest = "129 West 81st Street"; // collected from user
TravelOffer offer;
if (user != null && !user.isBlank()) { // is user login ?
offer = ScopedValue.where(USER, user)
.call(() -> fetchTravelOffers(loc, dest));
} else {
offer = fetchTravelOffers(loc, dest);
}
}
public static TravelOffer fetchTravelOffers(String loc, String dest) throws Exception {
return ScopedValue
.where(LOC, loc)
.where(DEST, dest)
.call(() -> {
try (TravelScope scope = new TravelScope()) {
if (USER.isBound()) {
scope.fork(() -> fetchRidesharingOffers());
} else {
logger.warning("Ridesharing services can be accessed only by login users");
}
scope.fork(() -> ScopedValue.where(PUBLIC_TRANSPORT_TICKET, true)
.call(Main::fetchPublicTransportOffers));
scope.join();
return scope.recommendedTravelOffer();
}
});
}
public static RidesharingOffer fetchRidesharingOffers() throws InterruptedException, Exception {
logger.info(() -> "Ridesharing: Processing request for "
+ USER.orElseThrow(() -> new RuntimeException("Ridesharing: User not login")));
try (StructuredTaskScope scope = new StructuredTaskScope<RidesharingOffer>()) {
Subtask<RidesharingOffer> carOneOffer
= scope.fork(() -> ScopedValue.where(CAR_ONE_DISCOUNT, 0.5)
.call(Ridesharing::carOneServer));
Subtask<RidesharingOffer> starCarOffer
= scope.fork(Ridesharing::starCarServer);
Subtask<RidesharingOffer> topCarOffer
= scope.fork(Ridesharing::topCarServer);
scope.join();
RidesharingOffer offer = Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.SUCCESS)
.<RidesharingOffer>mapMulti((s, c) -> {
c.accept((RidesharingOffer) s.get());
})
.min(Comparator.comparingDouble(RidesharingOffer::price))
.orElseThrow(() -> {
RidesharingException exceptionWrapper
= new RidesharingException("Ridesharing exception");
Stream.of(carOneOffer, starCarOffer, topCarOffer)
.filter(s -> s.state() == Subtask.State.FAILED)
.<Throwable>mapMulti((s, c) -> {
c.accept(s.exception());
}).forEach(exceptionWrapper::addSuppressed);
throw exceptionWrapper;
});
return offer;
}
}
public static PublicTransportOffer fetchPublicTransportOffers() throws InterruptedException {
logger.info(() -> "Public Transport: Processing request for " + USER.orElse("anonymous"));
try (PublicTransportScope scope = new PublicTransportScope()) {
scope.fork(PublicTransport::busTransportServer);
scope.fork(PublicTransport::subwayTransportServer);
scope.fork(PublicTransport::trainTransportServer);
scope.fork(PublicTransport::tramTransportServer);
scope.join();
PublicTransportOffer offer = scope.recommendedPublicTransport();
return offer;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/RidesharingOffer.java | package modern.challenge;
import java.time.Duration;
public record RidesharingOffer(String company, Duration minutesToYou,
Duration minutesToDest, double price) implements Travel {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | Chapter11/P234_ScopedValueAndStructuredTaskScope/src/main/java/modern/challenge/RidesharingException.java | package modern.challenge;
public class RidesharingException extends RuntimeException {
public RidesharingException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P231_IntroScopedValues3/src/main/java/modern/challenge/Main.java | Chapter11/P231_IntroScopedValues3/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.Callable;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable taskr = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound");
};
Callable<Boolean> taskc = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.isBound() ? SCOPED_VALUE.get() : "Not bound");
return true;
};
Thread tpr = new Thread(() -> ScopedValue.where(SCOPED_VALUE, "Kaboooom-r!").run(taskr));
// or, via of Platform()
// Thread tpr = Thread.ofPlatform().unstarted(
// () -> ScopedValue.where(SCOPED_VALUE, "Kaboooom-r!").run(taskr));
Thread tpc = new Thread(() -> {
try {
ScopedValue.where(SCOPED_VALUE, "Kaboooom-c!").call(taskc);
} catch (Exception ex) { /* handle exception */ }
});
// or, via of Platform()
// Thread tpc = Thread.ofPlatform().unstarted(()-> {
// try {
// ScopedValue.where(SCOPED_VALUE, "Kaboooom-c!").call(taskc);
// } catch (Exception ex) { /* handle exception */ }
// });
tpr.start();
tpc.start();
tpr.join();
tpc.join();
Thread tvr = Thread.ofVirtual().unstarted(
() -> ScopedValue.where(SCOPED_VALUE, "Kaboooom-r!").run(taskr));
Thread tvc = Thread.ofVirtual().unstarted(() -> {
try {
ScopedValue.where(SCOPED_VALUE, "Kaboooom-c!").call(taskc);
} catch (Exception ex) { /* handle exception */ }
});
tvr.start();
tvc.start();
tvr.join();
tvc.join();
Thread tpcx = new Thread(()
-> ScopedValue.where(SCOPED_VALUE, "Kaboooom-tpcx!").run(taskr));
Thread tpcy = new Thread(()
-> ScopedValue.where(SCOPED_VALUE, "Kaboooom-tpcy!").run(taskr));
tpcx.start();
tpcy.start();
tpcx.join();
tpcy.join();
Thread tpca = new Thread(()
-> ScopedValue.where(SCOPED_VALUE, "Kaboooom-tpca!").run(taskr));
Thread tpcb = new Thread(taskr);
tpca.start();
tpcb.start();
tpca.join();
tpcb.join();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P233_ChainRebindScopedValues/src/main/java/modern/challenge/Main.java | Chapter11/P233_ChainRebindScopedValues/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ScopedValue<String> SCOPED_VALUE_1 = ScopedValue.newInstance();
private static final ScopedValue<String> SCOPED_VALUE_2 = ScopedValue.newInstance();
private static final ScopedValue<String> SCOPED_VALUE_3 = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
// chaining where() calls
Runnable task = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE_1.isBound() ? SCOPED_VALUE_1.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_2.isBound() ? SCOPED_VALUE_2.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_3.isBound() ? SCOPED_VALUE_3.get() : "Not bound");
};
ScopedValue.where(SCOPED_VALUE_1, "Kaboooom - 1").run(task);
ScopedValue.where(SCOPED_VALUE_1, "Kaboooom - 1")
.where(SCOPED_VALUE_2, "Kaboooom - 2")
.run(task);
ScopedValue.where(SCOPED_VALUE_1, "Kaboooom - 1")
.where(SCOPED_VALUE_2, "Kaboooom - 2")
.where(SCOPED_VALUE_3, "Kaboooom - 3")
.run(task);
logger.info("-------------------------------------");
// rebind
Runnable taskB = () -> {
logger.info(() -> "taskB: " + Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE_1.isBound() ? SCOPED_VALUE_1.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_2.isBound() ? SCOPED_VALUE_2.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_3.isBound() ? SCOPED_VALUE_3.get() : "Not bound");
};
Runnable taskA = () -> {
logger.info(() -> "taskA: " + Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE_1.isBound() ? SCOPED_VALUE_1.get() : "Not bound");
ScopedValue.where(SCOPED_VALUE_1, "No kaboooom") // rebind
.where(SCOPED_VALUE_2, "Kaboooom - 2")
.where(SCOPED_VALUE_3, "Kaboooom - 3")
.run(taskB);
logger.info(() -> SCOPED_VALUE_1.isBound() ? SCOPED_VALUE_1.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_2.isBound() ? SCOPED_VALUE_2.get() : "Not bound");
logger.info(() -> SCOPED_VALUE_3.isBound() ? SCOPED_VALUE_3.get() : "Not bound");
};
ScopedValue.where(SCOPED_VALUE_1, "Kaboooom - 1").run(taskA);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P231_IntroScopedValues4/src/main/java/modern/challenge/Main.java | Chapter11/P231_IntroScopedValues4/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
public static void main(String[] args) throws InterruptedException, Exception {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable taskr1 = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.orElse("Not bound"));
};
Runnable taskr2 = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.orElseThrow(() -> new RuntimeException("Not bound")));
};
// taskr1.run();
// taskr2.run();
Runnable taskr = () -> {
logger.info(Thread.currentThread().toString());
logger.info(() -> SCOPED_VALUE.get());
};
Thread.ofVirtual().start(() -> ScopedValue.runWhere(
SCOPED_VALUE, SCOPED_VALUE.orElse("Kaboooom"), taskr)).join();
Thread.ofVirtual().start(() -> ScopedValue.runWhere(
SCOPED_VALUE, SCOPED_VALUE.orElseThrow(() -> new RuntimeException("Not bound")), taskr)).join();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P242_VirtualThreadsWaitNotify3/src/main/java/modern/challenge/SignaledObject.java | Chapter11/P242_VirtualThreadsWaitNotify3/src/main/java/modern/challenge/SignaledObject.java | package modern.challenge;
import java.util.logging.Logger;
public class SignaledObject {
private static final Logger logger = Logger.getLogger(SignaledObject.class.getName());
private int counter;
public void callWait() throws InterruptedException {
synchronized (this) {
counter = counter - 1;
if (counter >= 0) {
logger.info(() -> Thread.currentThread()
+ " | Missed signals: " + counter + " | 'wait() will not be called'");
return;
}
logger.info("Before calling wait()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
wait();
logger.info("After calling notify()");
logger.info(() -> Thread.currentThread() + " | " + Thread.currentThread().getState());
}
}
public void callNotify() {
synchronized (this) {
counter = counter + 1;
logger.info(() -> "Signal counter: " + counter);
notify();
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P242_VirtualThreadsWaitNotify3/src/main/java/modern/challenge/Main.java | Chapter11/P242_VirtualThreadsWaitNotify3/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
SignaledObject object = new SignaledObject();
Thread wThread = Thread.ofVirtual().unstarted(() -> {
try {
object.callWait();
} catch (InterruptedException ex) {}
});
Thread nThread = Thread.ofVirtual().unstarted(() -> {
object.callNotify();
});
// good signal
/*
wThread.start();
Thread.sleep(1000); // give time to 'wThread' to start
logger.info("'wThread' current status");
logger.info(() -> wThread + " | " + wThread.getState());
nThread.start();
Thread.sleep(1000); // give time to 'nThread' to start
logger.info("After executing 'wThread'");
logger.info(() -> wThread + " | " + wThread.getState());
*/
// missed signal
nThread.start();
Thread.sleep(1000); // give time to 'nThread' to start
wThread.start();
Thread.sleep(1000); // give time to 'wThread' to start
logger.info("'wThread' current status");
logger.info(() -> wThread + " | " + wThread.getState());
wThread.join();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P237_VirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | Chapter11/P237_VirtualThreadProducerConsumer/src/main/java/modern/challenge/AssemblyLine.java | package modern.challenge;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
public final class AssemblyLine {
private AssemblyLine() {
throw new AssertionError("There is a single assembly line!");
}
private static final int PRODUCERS = 3;
private static final int CONSUMERS = 2;
private static final int MAX_PROD_TIME_MS = 2 * 1000;
private static final int MAX_CONS_TIME_MS = 2 * 1000;
private static final int TIMEOUT_MS = (MAX_PROD_TIME_MS + MAX_CONS_TIME_MS)
* (PRODUCERS + CONSUMERS);
private static final Logger logger = Logger.getLogger(AssemblyLine.class.getName());
private static final Random rnd = new Random();
private static final Queue<String> queue = new ConcurrentLinkedQueue<>();
private static volatile boolean runningProducer;
private static volatile boolean runningConsumer;
private static final Producer producer = new Producer();
private static final Consumer consumer = new Consumer();
private static ExecutorService producerService;
private static ExecutorService consumerService;
private static class Producer implements Runnable {
@Override
public void run() {
while (runningProducer) {
try {
String bulb = "bulb-" + rnd.nextInt(1000);
Thread.sleep(rnd.nextInt(MAX_PROD_TIME_MS));
queue.offer(bulb);
logger.info(() -> "Checked: " + bulb + " by producer: "
+ Thread.currentThread().toString());
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
break;
}
}
}
}
private static class Consumer implements Runnable {
@Override
public void run() {
while (runningConsumer) {
try {
String bulb = queue.poll();
if (bulb != null) {
Thread.sleep(rnd.nextInt(MAX_CONS_TIME_MS));
logger.info(() -> "Packed: " + bulb + " by consumer: "
+ Thread.currentThread().toString());
}
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
break;
}
}
}
}
public static void startAssemblyLine() {
if (runningProducer || runningConsumer) {
logger.info("Assembly line is already running ...");
return;
}
logger.info("\n\nStarting assembly line ...");
logger.info(() -> "Remaining bulbs from previous run: \n" + queue + "\n\n");
runningProducer = true;
producerService = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < PRODUCERS; i++) {
producerService.execute(producer);
}
runningConsumer = true;
consumerService = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < CONSUMERS; i++) {
consumerService.execute(consumer);
}
}
public static void stopAssemblyLine() {
logger.info("Stopping assembly line ...");
boolean isProducerDown = shutdownProducer();
boolean isConsumerDown = shutdownConsumer();
if (!isProducerDown || !isConsumerDown) {
logger.severe("Something abnormal happened during shutting down the assembling line!");
System.exit(0);
}
logger.info("Assembling line was successfully stopped!");
}
private static boolean shutdownProducer() {
runningProducer = false;
return shutdownExecutor(producerService);
}
private static boolean shutdownConsumer() {
runningConsumer = false;
return shutdownExecutor(consumerService);
}
private static boolean shutdownExecutor(ExecutorService executor) {
executor.shutdown();
try {
if (!executor.awaitTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
executor.shutdownNow();
return executor.awaitTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS);
}
return true;
} catch (InterruptedException ex) {
executor.shutdownNow();
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
}
return false;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter11/P237_VirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | Chapter11/P237_VirtualThreadProducerConsumer/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
AssemblyLine.startAssemblyLine();
Thread.sleep(60 * 100);
AssemblyLine.stopAssemblyLine();
Thread.sleep(2000);
System.out.println("\nStarting assembly line again ...");
AssemblyLine.startAssemblyLine();
Thread.sleep(60 * 100);
AssemblyLine.stopAssemblyLine();
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P215_ContextSwitching2/src/main/java/modern/challenge/Main.java | Chapter10/P215_ContextSwitching2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
Runnable slowTask = () -> {
logger.info(() -> Thread.currentThread().toString() + " | working on something");
logger.info(() -> Thread.currentThread().toString() + " | break time (blocking)");
try { Thread.sleep(Duration.ofSeconds(5)); } catch (InterruptedException ex) {} // blocking
logger.info(() -> Thread.currentThread().toString() + " | work done");
};
Runnable fastTask = () -> {
logger.info(() -> Thread.currentThread().toString() + " | working on something");
logger.info(() -> Thread.currentThread().toString() + " | break time (blocking)");
try { Thread.sleep(Duration.ofSeconds(1)); } catch (InterruptedException ex) {} // blocking
logger.info(() -> Thread.currentThread().toString() + " | work done");
};
Thread st = Thread.ofVirtual().name("slow-", 0).start(slowTask);
Thread ft = Thread.ofVirtual().name("fast-", 0).start(fastTask);
st.join();
ft.join();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P215_ContextSwitching1/src/main/java/modern/challenge/Main.java | Chapter10/P215_ContextSwitching1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final int MAX_THREADS = 10;
static class SimpleThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
// return new Thread(r); // classic thread
return Thread.ofVirtual().unstarted(r); // virtual thread
}
}
public static void main(String[] args) {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
try (ExecutorService executor = Executors.newThreadPerTaskExecutor(new SimpleThreadFactory())) {
for (int i = 0; i < MAX_THREADS; i++) {
int index = i;
executor.submit(() -> doSomething(index));
}
}
}
public static void doSomething(int index) {
logger.info(() -> index + " " + Thread.currentThread().toString());
try { Thread.sleep(Duration.ofSeconds(3)); } catch (InterruptedException ex) {}
logger.info(() -> index + " " + Thread.currentThread().toString());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJmx2/src/main/java/modern/challenge/Main.java | Chapter10/P224_MonitoringVirtualThreadsJmx2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import java.util.stream.IntStream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
logger.info("Sleeping 15s ... ");
Thread.sleep(Duration.ofSeconds(15)); // connect 'jconsole' while sleeping
logger.info("Done ... ");
ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(1);
scheduledExecutor.scheduleAtFixedRate(() -> {
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
ThreadInfo[] threadInfo = threadBean.dumpAllThreads(false, false);
logger.info(() -> "Platform threads: " + threadInfo.length);
}, 500, 500, TimeUnit.MILLISECONDS);
long start = System.currentTimeMillis();
try (ExecutorService executorFixed = Executors.newFixedThreadPool(200)) {
IntStream.range(0, 10_000).forEach(i -> {
executorFixed.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
logger.info(() -> "Task: " + i);
return i;
});
});
}
logger.info(() -> "Time (ms): " + (System.currentTimeMillis() - start));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/Main.java | Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;
import java.util.stream.Stream;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnSuccess;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
buildTestingTeam();
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnSuccess scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
Stream.of(1, 2, 3)
.<Callable<String>>map(id -> () -> fetchTester(id))
.forEach(scope::fork);
scope.join();
String result = (String) scope.result();
logger.info(result);
return new TestingTeam(result);
}
}
public static synchronized String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
// intentionally added a delay of 1-5 seconds
Thread.sleep(Duration.ofMillis(ThreadLocalRandom.current().nextLong(5000)));
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P224_MonitoringVirtualThreadsJfr2/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P216_NewVirtualThreadPerTaskExecutorInvokeAllAny/src/main/java/modern/challenge/Main.java | Chapter10/P216_NewVirtualThreadPerTaskExecutorInvokeAllAny/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
List<Future<String>> futures = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02", () -> "pass03")
);
futures.forEach(f -> logger.info(() -> "State: " + f.state()));
}
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
String result = executor.invokeAny(
List.of(() -> "pass01", () -> "pass02", () -> "pass03")
);
logger.info(result);
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P211_IntroStartVirtualThreadBuilder/src/main/java/modern/challenge/Main.java | Chapter10/P211_IntroStartVirtualThreadBuilder/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task = () -> logger.info(Thread.currentThread().toString());
logger.info("Before running the task ...");
Thread.Builder builder
= Thread.ofVirtual().name("vThread-", 1);
// name "vThread-1"
Thread vThread1 = builder.start(task);
vThread1.join();
logger.info(() -> vThread1.getName() + " terminated");
// name "vThread-2"
Thread vThread2 = builder.start(task);
vThread2.join();
logger.info(() -> vThread2.getName() + " terminated");
logger.info("After running the task ...");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/Main.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnSuccess;
import java.util.concurrent.StructuredTaskScope.Subtask;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
buildTestingTeam();
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnSuccess scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
Subtask<String> subtask1 = scope.fork(() -> fetchTester(1));
Subtask<String> subtask2 = scope.fork(() -> fetchTester(2));
Subtask<String> subtask3 = scope.fork(() -> fetchTester(3));
scope.join();
logger.info(() -> "Subtask-1 state: " + subtask1.state());
logger.info(() -> "Subtask-2 state: " + subtask2.state());
logger.info(() -> "Subtask-3 state: " + subtask3.state());
String result = (String) scope.result();
logger.info(result);
return new TestingTeam(result);
}
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
// intentionally added a delay of 1-5 seconds
Thread.sleep(Duration.ofMillis(ThreadLocalRandom.current().nextLong(5000)));
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess1/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/Main.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnFailure;
import java.util.concurrent.StructuredTaskScope.Subtask;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
buildTestingTeam();
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnFailure scope = new StructuredTaskScope.ShutdownOnFailure()) {
Subtask<String> subtask1 = scope.fork(() -> fetchTester(1));
Subtask<String> subtask2 = scope.fork(() -> fetchTester(2));
Subtask<String> subtask3 = scope.fork(() -> fetchTester(Integer.MAX_VALUE));
scope.join();
logger.info(() -> "Subtask-1 state: " + subtask1.state());
logger.info(() -> "Subtask-2 state: " + subtask2.state());
logger.info(() -> "Subtask-3 state: " + subtask3.state());
Optional<Throwable> exception = scope.exception();
if (exception.isEmpty()) {
logger.info(() -> "Subtask-1 result: " + subtask1.get());
logger.info(() -> "Subtask-2 result: " + subtask2.get());
logger.info(() -> "Subtask-3 result: " + subtask3.get());
return new TestingTeam(subtask1.get(), subtask2.get(), subtask3.get());
} else {
logger.info(() -> exception.get().getMessage());
scope.throwIfFailed();
}
}
return new TestingTeam();
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure1/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P214_VirtualThreadsAndSyncCode2/src/main/java/modern/challenge/Main.java | Chapter10/P214_VirtualThreadsAndSyncCode2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.concurrent.SynchronousQueue;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable taskp = () -> {
logger.info(() -> Thread.currentThread().toString() + " sleeps for 5 seconds");
try { Thread.sleep(Duration.ofSeconds(5)); } catch (InterruptedException ex) {}
logger.info(() -> Thread.currentThread().toString() + " inserts in the queue");
queue.add(Integer.MAX_VALUE);
};
Runnable taskv = () -> {
logger.info(() -> Thread.currentThread().toString()
+ " can't take from the queue yet");
try {
int maxint = queue.take();
logger.info(() -> Thread.currentThread().toString() + " took from queue: " + maxint);
} catch (InterruptedException ex) {}
};
logger.info("Before running the task ...");
Thread pThread = Thread.ofPlatform().start(taskp);
logger.info(pThread.toString());
Thread vThread = Thread.ofVirtual().start(taskv);
vThread.join();
logger.info("After running the task ...");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P213_VirtualThreadForkJoinPool/src/main/java/modern/challenge/Main.java | Chapter10/P213_VirtualThreadForkJoinPool/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
private static final int NUMBER_OF_TASKS = Runtime.getRuntime().availableProcessors();
public static void main(String[] args) {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable taskr = () -> logger.info(Thread.currentThread().toString());
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < NUMBER_OF_TASKS + 1; i++) {
executor.submit(taskr);
}
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P219_NewVirtualThreadPerTaskExecutorStream2/src/main/java/modern/challenge/Main.java | Chapter10/P219_NewVirtualThreadPerTaskExecutorStream2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Logger;
import java.util.stream.Collectors;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
List<String> results1 = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02", () -> "pass03"))
.stream()
.filter(f -> f.state() == Future.State.SUCCESS)
.<String>mapMulti((f, c) -> {
c.accept((String) f.resultNow());
}).collect(Collectors.toList());
List<String> results2 = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02", () -> "pass03"))
.stream()
.filter(f -> f.state() == Future.State.SUCCESS)
.map(f -> f.resultNow().toString())
.toList();
List<Object> results3 = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02", () -> "pass03"))
.stream()
.filter(f -> f.state() == Future.State.SUCCESS)
.map(Future::resultNow)
.toList();
logger.info(results1.toString());
logger.info(results2.toString());
logger.info(results3.toString());
List<Throwable> exceptions1 = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02".substring(50), () -> "pass03"))
.stream()
.filter(f -> f.state() == Future.State.FAILED)
.<Throwable>mapMulti((f, c) -> {
c.accept((Throwable) f.exceptionNow());
}).collect(Collectors.toList());
List<Throwable> exceptions2 = executor.invokeAll(
List.of(() -> "pass01", () -> "pass02".substring(50), () -> "pass03"))
.stream()
.filter(f -> f.state() == Future.State.FAILED)
.map(Future::exceptionNow)
.toList();
logger.severe(exceptions1.toString());
logger.severe(exceptions2.toString());
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P211_HowManyThreadsCreate/src/main/java/modern/challenge/Main.java | Chapter10/P211_HowManyThreadsCreate/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.LockSupport;
public class Main {
public static void main(String[] args) {
// CREATING PLATFORM THREADS
// ATTENTION, THIS CODE MAY SIMPLY HANG ON OR GENERATE AN ERROR: OutOfMemoryError
/*
AtomicLong counterOSThreads = new AtomicLong();
while (true) {
Thread.ofPlatform().start(() -> {
long currentOSThreadNr = counterOSThreads.incrementAndGet();
System.out.println("Thread: " + currentOSThreadNr);
LockSupport.park();
});
}
*/
/*
AtomicLong counterOSThreads = new AtomicLong();
while (true) {
new Thread(() -> {
long currentOSThreadNr = counterOSThreads.incrementAndGet();
System.out.println("Thread: " + currentOSThreadNr);
LockSupport.park();
}).start();
}
*/
// CREATING VIRTUAL THREADS
// ATTENTION, THIS CODE MAY RUN FOR A LONG TIME (MORE THAN 10 MILLIONS VIRTUAL THREADS)
AtomicLong counterOSThreads = new AtomicLong();
while (true) {
Thread.startVirtualThread(() -> {
long currentOSThreadNr = counterOSThreads.incrementAndGet();
System.out.println("Virtual thread: " + currentOSThreadNr);
LockSupport.park();
});
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/Main.java | Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Logger;
import java.util.stream.Stream;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnSuccess;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
buildTestingTeam();
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnSuccess scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
Stream.of(1, 2, 3)
.<Callable<String>>map(id -> () -> fetchTester(id))
.forEach(scope::fork);
scope.join();
String result = (String) scope.result();
logger.info(result);
return new TestingTeam(result);
}
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
// intentionally added a delay of 1-5 seconds
Thread.sleep(Duration.ofMillis(ThreadLocalRandom.current().nextLong(5000)));
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P224_MonitoringVirtualThreadsJfr1/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/Main.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnSuccess;
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
System.out.println(buildTestingTeam());
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnSuccess scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
scope.fork(() -> fetchTester(1));
scope.fork(() -> fetchTester(2));
scope.fork(() -> fetchTester(3));
scope.join();
return new TestingTeam((String) scope.result());
}
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
// intentionally added a delay of 1-5 seconds
Thread.sleep(Duration.ofMillis(ThreadLocalRandom.current().nextLong(5000)));
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P221_IntroStructuredTaskScopeOnSuccess2/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P219_NewVirtualThreadPerTaskExecutorStream1/src/main/java/modern/challenge/Main.java | Chapter10/P219_NewVirtualThreadPerTaskExecutorStream1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Logger;
import static java.util.stream.Collectors.toList;
import java.util.stream.IntStream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
List<Future<String>> futures = IntStream.range(0, 10)
.mapToObj(i -> executor.submit(() -> {
return Thread.currentThread().toString() + "(" + i + ")";
})).collect(toList());
futures.forEach(f -> {
try {
logger.info(f.get());
} catch (InterruptedException | ExecutionException ex) {
// handle exception
}
});
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P211_IntroUnstartedVirtualThread/src/main/java/modern/challenge/Main.java | Chapter10/P211_IntroUnstartedVirtualThread/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.logging.Logger;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
Runnable task = () -> logger.info(Thread.currentThread().toString());
logger.info("Before running the task ...");
Thread vThread = Thread.ofVirtual().unstarted(task);
// Thread.Builder builder = Thread.ofVirtual();
// Thread vThread = builder.unstarted(task);
logger.info(() -> "Virtual thread is created but not started ... " + vThread.isAlive());
vThread.start();
logger.info(() -> "While running the task (virtual thread started) ... " + vThread.isAlive());
vThread.join();
logger.info("After running the task ...");
// this is an unstarted platform thread
Thread pThread = Thread.ofPlatform().unstarted(task);
logger.info("");
logger.info(() -> "Platform thread is created but not started ... " + pThread.isAlive());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P215_ContextSwitching3/src/main/java/modern/challenge/Main.java | Chapter10/P215_ContextSwitching3/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.Duration;
import java.util.logging.Logger;
// THIS APPLICATION WILL JUST HANG ON, SO YOU SHOULD STOP IT MANUALLY
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
System.setProperty("jdk.virtualThreadScheduler.maxPoolSize", "1");
Runnable slowTask = () -> {
logger.info(() -> Thread.currentThread().toString() + " | working on something");
logger.info(() -> Thread.currentThread().toString() + " | break time (non-blocking)");
while(dummyTrue()) {} // non-blocking
logger.info(() -> Thread.currentThread().toString() + " | work done");
};
Runnable fastTask = () -> {
logger.info(() -> Thread.currentThread().toString() + " | working on something");
logger.info(() -> Thread.currentThread().toString() + " | break time (blocking)");
try { Thread.sleep(Duration.ofSeconds(1)); } catch (InterruptedException ex) {} // blocking
logger.info(() -> Thread.currentThread().toString() + " | work done");
};
Thread st = Thread.ofVirtual().name("slow-", 0).start(slowTask);
Thread ft = Thread.ofVirtual().name("fast-", 0).start(fastTask);
st.join(); // interrupt after 5 seconds, st.join(Duration.ofSeconds(5));
ft.join();
}
static boolean dummyTrue() { return true; }
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/UserNotFoundException.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/UserNotFoundException.java | package modern.challenge;
public class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/Main.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.ShutdownOnFailure;
import java.util.concurrent.StructuredTaskScope.Subtask;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException, ExecutionException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
buildTestingTeam();
}
public static TestingTeam buildTestingTeam() throws InterruptedException, ExecutionException {
try (ShutdownOnFailure scope = new StructuredTaskScope.ShutdownOnFailure()) {
Subtask<String> subtask1 = scope.fork(() -> fetchTester(1));
Subtask<String> subtask2 = scope.fork(() -> fetchTester(2));
Subtask<String> subtask3 = scope.fork(() -> fetchTester(Integer.MAX_VALUE)); // this will cause the exception
scope.join();
scope.throwIfFailed();
// because we have an exception the following code will not be executed
return new TestingTeam(subtask1.get(), subtask2.get(), subtask3.get());
}
}
public static String fetchTester(int id) throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
HttpRequest requestGet = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users/" + id))
.build();
HttpResponse<String> responseGet = client.send(
requestGet, HttpResponse.BodyHandlers.ofString());
if (responseGet.statusCode() == 200) {
return responseGet.body();
}
throw new UserNotFoundException("Code: " + responseGet.statusCode());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/TestingTeam.java | Chapter10/P222_IntroStructuredTaskScopeOnFailure2/src/main/java/modern/challenge/TestingTeam.java | package modern.challenge;
public record TestingTeam(String... testers) {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter10/P224_MonitoringVirtualThreadsJmx1/src/main/java/modern/challenge/Main.java | Chapter10/P224_MonitoringVirtualThreadsJmx1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import java.util.stream.IntStream;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) throws InterruptedException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"[%1$tT] [%4$-7s] %5$s %n");
logger.info("Sleeping 15s ... ");
Thread.sleep(Duration.ofSeconds(15)); // connect 'jconsole' while sleeping
logger.info("Done ... ");
ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(1);
scheduledExecutor.scheduleAtFixedRate(() -> {
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
ThreadInfo[] threadInfo = threadBean.dumpAllThreads(false, false);
logger.info(() -> "Platform threads: " + threadInfo.length);
}, 500, 500, TimeUnit.MILLISECONDS);
long start = System.currentTimeMillis();
try (ExecutorService executorCached = Executors.newCachedThreadPool()) {
IntStream.range(0, 10_000).forEach(i -> {
executorCached.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
logger.info(() -> "Task: " + i);
return i;
});
});
}
logger.info(() -> "Time (ms): " + (System.currentTimeMillis() - start));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.