You can understand and perfect the basics of DB data access technology required for backend development. You can understand the principles and structure of Spring DB access technology and grow into a more in-depth backend developer.
Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency Open Schedule Confirmed
hello everyone
Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
The opening date has been confirmed for Monday, July 15th .
Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
* Lecture time: 20 hours 48 minutes
* Number of lectures: 118
* Lecture PDF materials: Approximately 500 pages
* Picture: 270 sheets
Advanced Part 1 aims to completely master multithreading and concurrency, from CS basics to practical application techniques. And to explain complex multithreading as easily as possible, it includes a whopping 270 illustrations!
[Future plans]
The Advanced Edition will be released in three parts: 1, 2, and 3.
* Advanced Part 1: Multithreading and Concurrency (7/15)
* Advanced Part 2: I/O, Networks, Reflection, Annotations (Scheduled for October)
* Advanced Part 3: Lambda, Streams, Modern Java (scheduled for December)
[Course Introduction]
Kim Young-han's Practical Java - Advanced Part 1, Multithreading and Concurrency
Course Objectives
Beyond simply knowing the basics of threads, I will teach you how to deeply understand and properly utilize Java multithreading technology and concurrency issues required for practical use.
Lecture Contents
Learning CS theory to lay the foundation
* Processes and threads
* Multitasking
* Scheduling 2
Thread Basics
* Thread control
* Thread life cycle
* Memory visibility, volatile
* synchronized synchronization
* ReentrantLock - Advanced synchronization
* Thread Control - Various Examples
Advanced techniques in threading
* Producer Consumer Issues
* CAS
* Synchronized collection
Multithreaded practical techniques used in practice
* How Future Works
* Thread Pool and Executor Framework - Principles
* Thread Pool and Executor Framework - Practical Applications
[Full lecture table of contents]
1. Introduction to processes and threads
* Multitasking and multiprocessing
* Processes and threads
* Threads and scheduling
* Context switching
2. Creating and running threads
* Project environment configuration
* Thread start 1
* Thread start 2
* Daemon thread
* Create a thread - Runnable
* Create a logger
* Create multiple threads
* Various ways to create a Runnable
* Problems and solutions
* organize
3. Thread Control and Life Cycle1
* Thread basic information
* Thread Life Cycle - Explained
* Thread life cycle - code
* Redefine checked exceptions
* join - start
* join - necessary situation
* Use join - sleep
* join - use join
* join - wait only for a certain amount of time
* Problems and solutions
4. Thread Control and Life Cycle2
* Interrupt - Start1
* Interrupt - Start2
* Interrupt - Start 3
* Interrupt - Start 4
* Printer Example 1 - Start
* Printer Example 2 - Introducing Interrupts
* Printer Example 3 - Interrupt Code Improvement
* yield - to give in
* Printer Example 4 - Introducing yield
* organize
5. Memory Visibility
* volatile, memory visibility1
* volatile, memory visibility2
* volatile, memory visibility3
* volatile, memory visibility4
* Java Memory Model
* organize
6. Synchronization - synchronized
* Withdrawal Example - Start
* Concurrency issues
* Critical area
* synchronized method
* synchronized code block
* Problems and solutions
* organize
7. Advanced Synchronization - concurrent.Lock
* LockSupport1
* LockSupport2
* ReentrantLock - Theory
* ReentrantLock - Utilization
* ReentrantLock - ReentrantLock
* organize
8. Producer-Consumer Issues 1
* Producer Consumer Issues - Introduction
* Producer Consumer Problem - Example 1 Code
* Producer Consumer Problem - Analysis of Example 1 - Producer First
* Producer Consumer Problem - Analysis of Example 1 - Consumer First
* Producer Consumer Problem - Example 2 Code
* Producer Consumer Problem - Example 2 Analysis
* Object - wait, notify - Example 3 code
* Object - wait, notify - Example 3 Analysis - Producer priority
* Object - wait, notify - Example 3 Analysis - Consumer First
* Object - wait, notify - limits
* organize
9. Producer-Consumer Problems 2
* Lock Condition - Example 4
* Separate producer and consumer waiting space - Example 5 code
* Separation of producer-consumer waiting space - Analysis of Example 5
* Wait for thread
* Interim Summary - Producer Consumer Issues
* BlockingQueue - Example 6
* BlockingQueue - Function Description
* BlockingQueue - Check the function
* organize
10. CAS - Synchronization and Atomic Operations
* Atomic Operations - Introduction
* Atomic Operations - Start
* Atomic operations - volatile, synchronized
* Atomic operations - AtomicInteger
* Atomic Operations - Performance Testing
* CAS operation 1
* CAS operation 2
* CAS operation 3
* CAS lock implementation1
* CAS lock implementation 2
* organize
11. Concurrency Collection
* Why we need concurrent collections 1 - Getting started
* Why we need concurrent collections 2 - Concurrency issues
* Why we need concurrent collections 3 - Synchronization
* Why we need concurrent collections 4 - Introducing proxies
* Java Concurrency Collections 1 - synchronized
* Java Concurrency Collections 2 - Concurrency Collections
* organize
12. Thread Pool and Executor Framework1
* Problems with using threads directly
* Introduction to the Executor Framework
* Start with ExecutorService code
* Inconvenience of Runnable
* Future1 - Introduction
* Future2 - Analysis
* Future3 - Utilization
* Future4 - Reason
* Future5 - Summary
* Future6 - Cancel
* Future7 - Exception
* ExecutorService - Processes a collection of tasks.
* Problems and solutions
* organize
13. Thread Pool and Executor Framework2
* ExecutorService Graceful Shutdown - Introduction
* ExecutorService graceful shutdown - implementation
* Executor thread pool management - code
* Executor thread pool management - Analysis
* Executor Strategy - Fixed Pool Strategy
* Executor Strategy - Cache Pool Strategy
* Executor Strategy - Custom Pool Strategy
* Executor exception policy
* organize
thank you