강의

멘토링

커뮤니티

Programming

/

Back-end

The Easiest Concurrency Problem - Race Condition

Learn about Race Condition, a representative concurrency problem. Practice by comparing single server environments and distributed environments that cause concurrency issues. Understand transaction boundaries and isolation levels. Learn the differences between optimistic locking, pessimistic locking, and distributed locking.

(5.0) 4 reviews

44 learners

Level Basic

Course period Unlimited

  • joyopi
실습 중심
실습 중심
낙관적락
낙관적락
비관적락
비관적락
분산락
분산락
동시성문제
동시성문제
Docker
Docker
Spring Boot
Spring Boot
DBMS/RDBMS
DBMS/RDBMS
Redis
Redis
k6
k6
실습 중심
실습 중심
낙관적락
낙관적락
비관적락
비관적락
분산락
분산락
동시성문제
동시성문제
Docker
Docker
Spring Boot
Spring Boot
DBMS/RDBMS
DBMS/RDBMS
Redis
Redis
k6
k6

Reviews from Early Learners

What you will gain after the course

  • Fundamental Causes and Solutions for Concurrency Issues

  • Methods for Solving Concurrency Issues in Single Server and Distributed Server Environments

  • Properly Understanding and Using Optimistic Locking, Pessimistic Locking, and Distributed Locking

  • Understanding Transaction Boundaries and Isolation Levels

  • How to Use IntelliJ IDEA, Docker, and k6

Are you still confused about concurrency issues?

Through this course, accurately understand the concepts and solutions for concurrency issues such as optimistic locking, pessimistic locking, and distributed locking.

  • Create an environment that causes concurrency issues to actually experience concurrency problems.

  • Check the differences in concurrency issues between single-server environments and distributed server environments.

  • You can understand how to use the @Transactional annotation that you used without knowing exactly how it worked.

  • Why are there multiple solutions when concurrency problems are singular? Let's check the reasons.

We recommend this for people like this

Who should take this course (1)

I still don't really understand concurrency issues. 😅

Who should take this course (2)

I don't have a precise understanding of the differences between optimistic locking, pessimistic locking, and distributed locking. 🌧️

Who should take this course (3)

How should I test concurrency issues? 📜

After taking the course

  • You can understand race conditions, which are the most common concurrency issues that occur in practice.

  • You can properly use the @Transactional annotation that you used to use without fully understanding it.

  • You can understand and accurately solve concurrency issues in both single-server and distributed server environments.

  • You can understand transaction isolation levels and boundaries and apply them in practice.

Features of this course

Utilizing IntelliJ IDEA for convenient practice and providing course materials through Notion and Github

Key Strength of This Course (1)

I didn't know IntelliJ had this feature. 😲

We'll send test requests to the running API application, connect to the DB to manage data, and view data stored in Redis - all at once in IntelliJ.

Key Strengths of This Course (2)

We provide Notion course materials that reflect updates in real-time.

I provide the project code via GitHub link so you can follow along with the hands-on exercises easily.

You'll learn this kind of content

The fundamental reasons for concurrency issues and their solutions

Do you know the fundamental reason for concurrency problems?

By understanding the fundamental causes and learning solution methods, you can understand and solve problems more accurately.

The course starts by establishing the concept of concurrency issues from the ground up.

Various solutions for practicing in distributed environments

Concurrency issues occur differently in single-server environments and distributed server environments. Even when applying the same solution, the problem may not be resolved depending on the environment.

You need to know in what environment and how to use it to apply it directly to practical work.

Configure a distributed environment by running two applications simultaneously.

The person who created this lecture

  • (Current) AhnLab Backend Developer


Do you have any questions?

Q. The topic of concurrency issues feels too difficult. 🫥

The reason concurrency issues feel difficult is not because the concepts are complex, but because you can't get a feel for them until you experience them directly in practice.
This course explains only the core concepts with a focus on hands-on practice.
You can verify everything with code immediately, so you'll be able to understand quickly.

Q. I'm still not very familiar with Spring Boot or JPA. 🤦‍♀️

You don't need to have deep knowledge of Spring Boot and JPA.
Concurrency concepts can be understood separately from frameworks.
The course explains only the necessary parts minimally and applies them directly to practice.
The project code used in the practice sessions is also provided on GitHub, so you can follow along right away.

Q. Do concurrency issues occur frequently in real-world practice❓

Yes, it occurs frequently in actual services.
It appears almost inevitably in structures with high traffic or shared resource access.
It's particularly common in state-changing logic like inventory reduction, payments, and reservations.
That's why considering concurrency control strategies from the initial design phase is recommended in practice.

Pre-enrollment Reference Information

Instructor's Practice Environment

  • Operating system and version: Windows 11

  • Tools Used: IntelliJ IDEA Ultimate Edition, Docker, k6, Spring Boot, DBMS/RDBMS, Redis


Prerequisites and Important Notes

  • Spring Boot, JPA, RDBMS

  • This lecture practices concurrency issues in an environment that creates many requests instantaneously, but it is not a lecture about how to handle large volumes of requests without problems.

  • I'd like to inform you that handling large volumes of requests and dealing with concurrency issues are different topics.

Recommended for
these people

Who is this course right for?

  • A developer who continues to be confused by concurrency issues and is troubled by finding solutions

  • A developer who wants to understand transactions related to concurrency issues

  • Developers who want to understand and apply the differences between optimistic locking, pessimistic locking, and distributed locking

Need to know before starting?

  • Simple API backend server development experience (Spring Boot)

  • Basic knowledge of databases (RDBMS, NoSQL)

Hello
This is

44

Learners

4

Reviews

5.0

Rating

1

Course

(현) 안랩 백엔드 개발자

Curriculum

All

25 lectures ∙ (3hr 54min)

Published: 
Last updated: 

Reviews

All

4 reviews

5.0

4 reviews

  • heejaykong2906님의 프로필 이미지
    heejaykong2906

    Reviews 1

    Average Rating 5.0

    5

    100% enrolled

    I only knew about concurrency issues theoretically, but by following the instructor to directly reproduce and solve race conditions at the code level, I was able to gain a solid understanding. Practicing under various environment assumptions such as shared DB and distributed environments was also very helpful. 😊😊 I think this is a great course for those like me who are just getting started with concurrency issues. Thank you~

    • joyopi
      Instructor

      The feedback that you were able to grasp the concept firmly by directly reproducing and solving concurrency issues in code, which you previously only knew in theory, is a very important part for me. Actually, this was the biggest goal when I was planning the course. I hope that practicing with practical environments like shared DB or distributed environments in mind will be of great help to you in real-world work. Your comment that it seems like it will be a good course for concurrency beginners also gives me great strength. Thank you for leaving such a nice review! 🙇

  • hyunwoochoi4034님의 프로필 이미지
    hyunwoochoi4034

    Reviews 1

    Average Rating 5.0

    Edited

    5

    100% enrolled

    I've always found concurrency issues difficult to grasp, but this course broke down the concepts step by step, and I finally feel like I'm getting the hang of it. Rather than just covering theory, I was able to naturally understand how concurrency issues manifest differently in single-server versus distributed-server environments by setting up hands-on practice environments. What I particularly appreciated was the structure that allowed me to directly observe the process through which concurrency issues actually occur, so instead of simply memorizing concepts, I could experience firsthand why these problems arise. There was a lot of content that could be immediately applied in real-world work, which was very helpful. I think this is a course worth recommending to anyone who finds concepts like optimistic locking, pessimistic locking, and distributed locking confusing, or who is struggling with how to solve concurrency problems.

    • joyopi
      Instructor

      Thank you so much for leaving such a thoughtful review. Concurrency is actually an invisible concept, so it's naturally a difficult topic to grasp, but I'm proud as an instructor that you were able to get a feel for it through the course, and I'm pleased that you recognized my intention of 'experiencing through hands-on practice rather than theory.' Great job completing the course. Thank you! 🙇‍♀️

  • abcd123123님의 프로필 이미지
    abcd123123

    Reviews 327

    Average Rating 5.0

    5

    100% enrolled

    • paulmoon008308님의 프로필 이미지
      paulmoon008308

      Reviews 111

      Average Rating 4.9

      5

      20% enrolled

      $38.50

      Similar courses

      Explore other courses in the same field!