인프런 영문 브랜드 로고
인프런 영문 브랜드 로고
BEST
Programming

/

Back-end

Real-world! Spring Boot and JPA Utilization 1 - Web Application Development

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.

(5.0) 2,137 reviews

24,804 students

Java
Spring
Web Application
Spring Boot
JPA
Thumbnail
yh님의 프로필 이미지

Edited

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

Comment