Spring Security

Hello. I am knowledge sharer Jeong Su-won. ^^

I would like to share with you, my students who love my lectures and have supported me, news about a new course that is about to open soon.

The course that will open this time is

Java Concurrency Programming
(Subtitle: Reactive Programming Part.1)

no see.

Concurrency programming in Java is one of the most difficult, complex, and high-barrier areas of Java technology.

However, in modern software development, the areas of multi-threading and concurrent development are becoming increasingly important as the scale of systems grows and technologies advance.

So, for backend developers, concurrent programming is a mountain they must overcome and a necessary gateway to take their capabilities to the next level.

This lecture is the first in a series of lectures included in the upcoming reactive programming roadmap, and will serve as a foundation for building the essential fundamentals and fundamentals for a deep and accurate understanding of asynchronous non-blocking concepts such as Spring's WebFlux.

I hope that this Java concurrent programming lecture will be a good guide for you into the world of concurrent programming.

Open and lecture information is as follows:

- Lecture opening date: Expected to be around November 21st ~ 28th
- Course name : Java Concurrency Programming - Reactive Programming Part.1
- Number of lectures : Approximately 80 lectures
- Lecture materials PPT: Approximately 420 pages

This lecture will cover the following topics:

Section 1. Operating System Basics
Learn the fundamentals of operating systems, multitasking, and the differences between processes and threads.
You will also learn the basics of concurrent programming and the fundamental principles of scheduling through core operating system concepts such as Parallel & Concurrent, Context Switch, CPU Bound & I/O Bound, User Mode & Kernel Mode, etc.

Section 2. Java Thread Fundamentals - Thread Creation and Execution Structure
Learn in detail how to create, run, and terminate threads in Java. Simulate the life cycle of a thread by state and learn step-by-step what characteristics and execution flow each state has.

Section 3. Java Thread Fundamentals - Basic Thread API
Explains in-depth concepts and structure of Java's thread-related APIs.
You will learn in depth about concepts that you must know for implementing multi-threading, such as sleep, join, interrupt, and priority, as well as the structure and flow of connections between the JVM and OS through native method execution.

Section 4. Java Thread Fundamentals - Using Threads
Learn how to use threads effectively in real-world projects.
We cover topics such as interruption and recovery, and learn about thread groups, thread locals, and thread exception handling.

Section 5. Synchronization Fundamentals - Synchronization Concepts
Learn in depth the fundamental concepts of synchronization and its importance in a multithreading environment.
Learn in depth the basic concepts needed to understand synchronization techniques, such as synchronization and its relationship with the CPU, critical sequence, and safe thread configuration.

Section 6. Synchronization Fundamentals - Synchronization Techniques
We cover in depth the various techniques of synchronization and how to apply them.
Learn about the concepts of locks such as mutexes, semaphores, monitors, and spin locks, which are synchronization techniques, and strategies for protecting data and maintaining consistency using synchronization.

Section 7. Java Synchronization
Learn in depth the synchronization mechanisms provided by Java.
Covers various synchronization mechanisms provided by Java, including the concept of synchronized, condition variables, volatile, deadlock, etc.

Section 8. Java Locks
Learn about Java's Lock interface and various types of classes, and learn how to use Lock and solve synchronization problems using Lock.
In particular, we will look at the characteristics, pros and cons of write locks and read locks, and learn how to use conditional variables of locks and the correct usage method through practical examples.

Section 9. Java Synchronization Tool
Learn about the various synchronization tools provided by Java.
Learn practical application methods using tools such as Atomic Variables, Atomic * FieldUpdater, Countdown Latch, and Cyclic Barrier.

. Section 10. Java Concurrency Framework
Understand the concepts and features of the Executor, ExecutorService, and Executors classes provided by Java, and learn how to efficiently manage and optimize multithreaded applications using thread pools.
It also provides practical knowledge on how to process and manage the results of asynchronous operations through the Future interface.
By applying these concepts through real-world examples and exercises, you will be able to solve complex concurrency problems and develop responsive, high-performance Java applications.

Section 11. ThreadPoolExecutor
Learn in detail about the principles and usage of ThreadPoolExecutor.
This section covers how to create, manage, and optimize thread pools, and learn how to use thread pools to efficiently manage resources and exception handling, as well as the overall architecture and flow chart.

Section 12: CompletableFuture
This article delves deeper into CompletableFuture, an asynchronous programming feature in Java.
This powerful class, introduced in Java 8, will teach you the fundamental concepts of asynchronous programming, and how to structure and manage real-world workflows.
Each session details different methods and use cases for CompletableFuture, and you'll learn practical techniques for exception handling, result composition, and asynchronous task chaining.