Thinking Beyond Java 17: Virtual Threads, 18-21 & Beyond

Explore JDK 18 features: UTF eight as default care set, Ascii to Unicode encoding, string deduplication, inner-class memory leak notes, at and ad snippet tags, and a simple web server.

Explore the history of messaging, from smoke signals and beacons to semaphore and electric telegraphs, and discover how encoding, decoding, and character encoding shaped long-distance communication.

Understand how characters are defined and how character encoding assigns code points to bytes for transmission, enabling correct reading of text across networks.

Trace the history of character encoding from Morse and Baudot to ASCII and ISO 8859, and discover how Unicode emerged as a universal standard.

Learn how Unicode unifies global characters, remains backward compatible with ASCII, maps code points to bytes with UTF-8, UTF-16, and UTF-32, and uses U plus notation.

Explore how UTF-8 became the default encoding across languages, web pages, XML and JSON, and how JDK 18 adopts UTF-8 as the default for APIs.

Learn why Java 18 adopts UTF-8 as the default charset for standard APIs, improving portability across Windows, macOS, and Unix by unifying file I/O behavior and avoiding encoding mismatches.

Explain how non-static inner classes hold an implicit this$0 reference to outer class, risking memory leaks; from JDK 18 the reference is generated only when needed, enabling earlier garbage collection.

Improve Java memory efficiency by deduplicating string backing arrays across G1, serial, and parallel garbage collectors, reducing heap usage from duplicate strings without code changes.

Discover how the javadoc tool generates API documentation and embeds code snippets with pre, code, and @code, discuss shortcomings, and explain how the snippet tag from JDK 18 improves samples.

Learn to use the @snippet tag in Java documentation to add inline and external code snippets with language highlighting, ellipsis replacements, and a copy button for javadoc.

Explore how to embed and copy Java code snippets in api documentation using the @snippet tag with external files, and generate html docs via the Javadoc tool.

Explore how to spin up a simple http server for testing, mock data, or file sharing; Java offers a command line j web server or programmatic api based on com.sun.net.httpserver.

Start the simple web server from the command line with j web server to serve static files from a chosen directory on port 8000.

Start a simple web server with the Java API, configuring port 8080 and a served directory, then customize the handler for get requests and Json content.

Configure the simple web server with JDK 18 http handlers to serve json on get requests and return 204 for delete, while enabling extra headers and optional filtering and pre-processing.

Explore the DateTimeFormatter class in the java.time.format package, review iso_date and iso_date_time formatters, and examine localization and pattern method shortcomings that justify a new format in the next lecture.

Explore how the ofLocalizedPattern method in DateTimeFormatter yields a locale-specific formatter from a template, overcoming issues with predefined styles and enabling flexible month–date formatting.

Use the new factory methods new HashMap, new LinkedHashMap, new WeakHashMap, new HashSet, and new LinkedHashSet to specify expected sizes and avoid resizing, powered by the JDK 19 capacity calculation.

Learn how hash map table size can over-allocate in three scenarios—initial capacity, copy constructor, and put all—and how Java 19 changes the calculation to Math.ceil.

Explore JDK 20 changes as the compiler warns about lossy conversions in compound assignments with type casts, guarding against data loss and deprecating the java.net URL class.

Explore lossy conversions in Java via compound assignments, showing how casts cause data loss. See how JDK 20's lossy conversions lint warning helps catch these at compile time.

Starting from JDK 20, all public constructors of java.net.URL are deprecated; use java.net.URI to parse or construct URLs and call toURL() on URI, handling encoding/decoding to avoid vulnerabilities.

Explore the latest JDK 21 features, including pattern matching for switch, record patterns, and sequenced collections, and dive into virtual threads from Project Loom and structured concurrency for scalable Java.

Explore how switch expressions and pattern matching simplify Java code with arrow labels, no fall through, and exhaustive handling using type patterns.

Explore pattern matching for switch in Java 21, handling null values with a null case label, and use guarded patterns to lift conditional logic into switch labels.

Learn pattern matching for switch expressions on sealed interfaces, using enum constants and qualified labels to create exhaustive, readable code with guarded patterns and no unnecessary default cases.

Explore nested record patterns with pattern matching in Java, using a sealed registrant hierarchy (person, company, vendor, volunteer) to extract name, email, city, and state for personalized welcome messages.

Explore why sequenced collections were added in JDK 21 to standardize encounter order, first and last element access, and reverse iteration across sequence collection, sequence set, and sequence map.

Explore the sequenced collection family and its extensions, learn how reverse views work without mutating data, and master first/last element access with JDK 21 enhancements for lists, sets, and maps.

Explore green threads, platform threads, and the thread-per-request model, and apply Little's Law to understand concurrency. Learn the current limitations and why virtual threads become imperative for modern concurrency.

Discover how virtual threads, scheduled by the JVM, enable scalable asynchronous code. They are not bound 1:1 to OS threads, mounting on carrier threads and unmounting during blocking I/O.

Demonstrates creating a million virtual threads concurrently using start virtual thread, builder, and off virtual methods, then executing tasks with new virtual thread per task executors.

Explore how virtual threads in Java 21 boost throughput for I/O workloads by enabling millions of lightweight threads without blocking OS threads.

Explore how virtual threads are created behind the scenes, focusing on the ForkJoinPool scheduler and thread continuations, and how different creation methods map to the virtual thread class.

Explore how virtual threads use continuations in the JVM, where a continuation object encapsulates a thread's task and enables suspend and resume through run and yield, with a practical demo.

Explain how virtual threads mount on carrier threads and use continuations to suspend during blocking input and output. Show how the JVM scheduler coordinates mounting, unmounting, yield, and stack management.

Explore how the lock support class in java.util.concurrent powers virtual threads, using park and unpark to coordinate threads via the scheduler and continuations.

Explore how virtual threads pin to carrier threads, detect pinning with the JDK trace pinned threads property, and compare synchronized blocks with reentrant locks for safe remounting.

Demonstrates why structured concurrency is needed to coordinate subtasks, prevent thread leaks, and ensure reliable cancellation and observability in Java code.

Explore structured concurrency using structured task scope to coordinate subtasks with fork and join, and see how shutdown on failure cancels remaining tasks on first error.

Explore structured concurrency with shutdown on success by forking three weather fetch subtasks, canceling the remaining tasks on first success, and using structured task scope, join, and result.

Explore structured concurrency with virtual threads, coordinating weather, activities, and restaurants via a structured task scope using fork, join, and shutdown on failure or success.

Get a sneak peek at JDK 22 features, including foreign functions and memory API as an alternative to JNI, G1 GC improvements, and the underscore convention for unused variables.