With a practical example, we will design and develop a web application using Spring Boot and JPA. Through this process, you will understand how to use Spring Boot and JPA in practice.
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