diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..9d2a6fa
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+Java-Concurrency-Programming
\ No newline at end of file
diff --git a/.idea/google-java-format.xml b/.idea/google-java-format.xml
new file mode 100644
index 0000000..2aa056d
--- /dev/null
+++ b/.idea/google-java-format.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GoogleJavaFormatSettings">
+    <option name="enabled" value="false" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 2a65317..ce1c62c 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -5,7 +5,6 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleHome" value="" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/.idea/misc.xml b/.idea/misc.xml
index f937d01..fe0b0da 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">
diff --git a/build.gradle.kts b/build.gradle
similarity index 99%
rename from build.gradle.kts
rename to build.gradle
index d299500..44dcf9f 100644
--- a/build.gradle.kts
+++ b/build.gradle
@@ -5,6 +5,7 @@ plugins {
 group = "io.concurrency"
 version = "1.0-SNAPSHOT"
 
+
 repositories {
     mavenCentral()
 }
diff --git a/settings.gradle.kts b/settings.gradle
similarity index 100%
rename from settings.gradle.kts
rename to settings.gradle
diff --git a/src/main/java/io/concurrency/chapter01/exam01/ConcurrencyExample.java b/src/main/java/io/concurrency/chapter01/exam01/ConcurrencyExample.java
index dcae22a..f3ef7e6 100644
--- a/src/main/java/io/concurrency/chapter01/exam01/ConcurrencyExample.java
+++ b/src/main/java/io/concurrency/chapter01/exam01/ConcurrencyExample.java
@@ -6,8 +6,10 @@
 public class ConcurrencyExample {
     public static void main(String[] args) {
 
+        //CPU 코어 수의 두 배만큼의 크기를 할당 (내 컴퓨터는 코어 16개)
         int cpuCores = Runtime.getRuntime().availableProcessors() * 2;
-//        int cpuCores = 13;
+
+        //int cpuCores = 17;
 
         // CPU 개수를 초과하는 데이터를 생성
         List<Integer> data = new ArrayList<>();
diff --git a/src/main/java/io/concurrency/chapter01/exam01/ParallelismExample.java b/src/main/java/io/concurrency/chapter01/exam01/ParallelismExample.java
index c7a2849..fa56065 100644
--- a/src/main/java/io/concurrency/chapter01/exam01/ParallelismExample.java
+++ b/src/main/java/io/concurrency/chapter01/exam01/ParallelismExample.java
@@ -6,7 +6,9 @@
 public class ParallelismExample {
     public static void main(String[] args) {
 //        int cpuCores = 1;
+        //내 컴퓨터의 CPU 코어 개수 가져오기. 내 컴퓨터는 코어 개수 16
         int cpuCores = Runtime.getRuntime().availableProcessors();
+        System.out.println("컴퓨터 코어 개수 = " + cpuCores);
 
         // CPU 개수만큼 데이터를 생성
         List<Integer> data = new ArrayList<>();
@@ -16,6 +18,10 @@ public static void main(String[] args) {
 
         // CPU 개수만큼 데이터를 병렬로 처리
         long startTime1 = System.currentTimeMillis();
+
+        //0부터 n까지의 데이터를 각각 쪼개서 하나의 데이터를
+        //하나의 스레드가 맡고, 그 작업을 동시에 독립적으로 처리
+        //즉, n+1개의 스레드가 생성
         long sum1 = data.parallelStream()
                 .mapToLong(i -> {
                     try {
diff --git a/src/main/java/io/concurrency/chapter01/exam01/README.md b/src/main/java/io/concurrency/chapter01/exam01/README.md
new file mode 100644
index 0000000..641643c
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter01/exam01/README.md
@@ -0,0 +1,82 @@
+#  ParallelismExample
+병렬성 확인
+
+```java
+//컴퓨터 CPU 코어 개수 가져오기. 내 경우 코어 개수 16개
+int cpuCores = Runtime.getRuntime().availableProcessors();
+
+// CPU 개수(16)만큼 데이터를 생성
+List<Integer> data = new ArrayList<>();
+for (int i = 0; i < cpuCores; i++) {
+    data.add(i);
+}
+
+long startTime1 = System.currentTimeMillis();
+
+long sum1 = data.parallelStream()
+                .mapToLong(i -> {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    return i * i;
+                })
+                .sum();
+long endTime1 = System.currentTimeMillis();
+
+System.out.println("CPU 개수만큼 데이터를 병렬로 처리하는 데 걸린 시간: " + (endTime1 - startTime1) + "ms");
+System.out.println("결과1: " + sum1);
+```
+- parallelStream을 통해 data 개수(CPU 개수)만큼의 스레드를 생성
+- 하나의 데이터를 하나의 스레드가 맡고, 그 합을 더하는 작업을 동시에 독립적으로 처리
+-
+```java
+컴퓨터 코어 개수 = 16
+CPU 개수만큼 데이터를 병렬로 처리하는 데 걸린 시간: 534ms
+결과1: 1240
+```
+- 병렬로 처리해서 0.5초 정도 걸림
+- 그럼 parallelStream을 stream으로 변경해서 수행해보면? (단일 스레드에서 연속적으로 연산 수행)
+```java
+컴퓨터 코어 개수 = 16
+CPU 개수만큼 데이터를 병렬로 처리하는 데 걸린 시간: 8117ms
+결과1: 1240
+```
+
+
+# ConcurrencyExample
+동시성 확인
+- CPU 코어 2배 만큼의 데이터를 생성하고, CPU 개수를 초과하는 데이터를 병려롤 처리하면?
+```java
+long startTime2 = System.currentTimeMillis();
+        long sum2 = data.parallelStream()
+                .mapToLong(i -> {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    return i * i;
+                })
+                .sum();
+
+        long endTime2 = System.currentTimeMillis();
+
+        System.out.println("CPU 개수를 초과하는 데이터를 병렬로 처리하는 데 걸린 시간: " + (endTime2 - startTime2) + "ms");
+        System.out.println("결과2: " + sum2);
+```
+```java
+CPU 개수를 초과하는 데이터를 병렬로 처리하는 데 걸린 시간: 1046ms
+결과2: 10416
+```
+
+- 병렬성 확인에서 보다 2배의 데이터를 처리하므로 시간이 더 소요된 것이라 볼 수도 있음.
+- 그럼 데이터 개수를 코어 개수보다 한 많은 17로 했을 떄, 병렬과 유사한 0.6초 정도 걸려야 함
+```java
+CPU 개수를 초과하는 데이터를 병렬로 처리하는 데 걸린 시간: 1020ms
+결과2: 1496
+```
+- 그러나 여전히 1초 정도 걸림
+  - 병렬성이라는 것은 정말 CPU 하나 당 스레드가 하나씩 붙어서 동시적으로 일괄 처리하는 상태를 말함. 그렇지만 CPU 개수보다 더 많은 작업을 처리해버리면 그 때는 병렬 이점을 가져가더라도 동시성도 적용되어버림
+  - 즉, 하나의 CPU가 동시에 2개의 스레드를 실행시키지 못하기 때문에, 한 스레드가 작업 중에 다른 스레드와 문맥 교환되어야 함
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter01/exam02/ContextSwitchExample.java b/src/main/java/io/concurrency/chapter01/exam02/ContextSwitchExample.java
index 1c44190..eabed55 100644
--- a/src/main/java/io/concurrency/chapter01/exam02/ContextSwitchExample.java
+++ b/src/main/java/io/concurrency/chapter01/exam02/ContextSwitchExample.java
@@ -36,6 +36,10 @@ public static void main(String[] args) {
             }
         });
 
+        //각 스레드가 순서 없이 번갈아 가며 값을 출력함
+        //CPU 스케줄러가 thread3을 가져왔다가 처리해서 thread 1을 가져오고 처리하고 thread 2를 가져와 처리하고..
+        //이런 식으로 문맥 교환이 일어나는 것임
+
         thread1.start();
         thread2.start();
         thread3.start();
diff --git a/src/main/java/io/concurrency/chapter01/exam02/README.md b/src/main/java/io/concurrency/chapter01/exam02/README.md
new file mode 100644
index 0000000..3d2ba16
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter01/exam02/README.md
@@ -0,0 +1,63 @@
+# ContextSwitchExample
+
+간단한 스레드 문맥 교환을 살펴봄
+
+```java
+        Thread thread1 = new Thread(() -> {
+            for (int i = 0; i < 5; i++) {
+                System.out.println("Thread 1: " + i);
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+
+        Thread thread2 = new Thread(() -> {
+            for (int i = 0; i < 5; i++) {
+                System.out.println("Thread 2: " + i);
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+
+        Thread thread3 = new Thread(() -> {
+            for (int i = 0; i < 5; i++) {
+                System.out.println("Thread 3: " + i);
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+```
+- 출력 결과를 보면 다음과 같음
+```java
+Thread 2: 0
+Thread 1: 0
+Thread 3: 0
+Thread 2: 1
+Thread 1: 1
+Thread 3: 1
+Thread 2: 2
+Thread 3: 2
+Thread 1: 2
+Thread 2: 3
+Thread 1: 3
+Thread 3: 3
+Thread 2: 4
+Thread 3: 4
+Thread 1: 4
+```
+- 각 스레드가 순서 없이 번갈아 가며 값을 출력하고 있음 -> 문맥 교환!!
+- CPU 스케줄러가 스레드 2를 가져가서 작업 처리한 후 스레드 1을 가져가 작업 처리하고, 스레드 3을 가져가 작업 처리하고...
+- 지금은 스레드 개수가 적어서 약간의 패턴이 보이긴 하지만, 스레드 개수가 많아지면 한 스레드의 작업이 길게 이어지기도 하고 어떤 규칙성이 안보임
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter01/exam03/CPUBoundExample.java b/src/main/java/io/concurrency/chapter01/exam03/CPUBoundExample.java
index a20b987..54cec82 100644
--- a/src/main/java/io/concurrency/chapter01/exam03/CPUBoundExample.java
+++ b/src/main/java/io/concurrency/chapter01/exam03/CPUBoundExample.java
@@ -10,7 +10,10 @@
 public class CPUBoundExample {
     public static void main(String[] args) throws InterruptedException {
 
+        //컴퓨터의 CPU 코어 개수 가져오기. 내 경우 16개 (병렬성 적용 위함)
         int numThreads = Runtime.getRuntime().availableProcessors();
+
+        //ExecutorService는 스레드를 만드는 생성기 (16개 스레드 생성)
         ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
 
         long startTime2 = System.currentTimeMillis();
@@ -19,7 +22,7 @@ public static void main(String[] args) throws InterruptedException {
         for (int i = 0; i < numThreads; i++) {
             Future<?> future = executorService.submit(() -> {
 
-                // Cpu 연산이 집중되고 오래 걸리는 작업
+                // Cpu 연산이 집중되고 오래 걸리는 작업 (가정)
                 long result = 0;
                 for (long j = 0; j < 1000000000L; j++) {
                     result += j;
@@ -46,7 +49,7 @@ public static void main(String[] args) throws InterruptedException {
             }
         });
         long endTime2 = System.currentTimeMillis();
-        System.out.println("CPU 개수를 초과하는 데이터를 병렬로 처리하는 데 걸린 시간: " + (endTime2 - startTime2) + "ms");
+        System.out.println("CPU 개수만큼의 데이터를 병렬로 처리하는 데 걸린 시간: " + (endTime2 - startTime2) + "ms");
         executorService.shutdown();
     }
 }
diff --git a/src/main/java/io/concurrency/chapter01/exam03/IOBoundExample.java b/src/main/java/io/concurrency/chapter01/exam03/IOBoundExample.java
index d21be0b..2c9896e 100644
--- a/src/main/java/io/concurrency/chapter01/exam03/IOBoundExample.java
+++ b/src/main/java/io/concurrency/chapter01/exam03/IOBoundExample.java
@@ -8,16 +8,17 @@
 
 public class IOBoundExample {
     public static void main(String[] args) {
-        int numThreads = Runtime.getRuntime().availableProcessors() / 2;
+        //내 컴퓨터 코어 수 2배 할당 (동시성 적용을 위함)
+        int numThreads = Runtime.getRuntime().availableProcessors() * 2;
         ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
 
         for (int i = 0; i < numThreads; i++) {
             executorService.submit(() -> {
                 try {
 
-                    // IO 가 집중 되는 작업
+                    // IO 가 집중 되는 작업 -> 이 때는 스레드가 대기. 따라서 다른 CPU가 다른 스레드 선택
                     for (int j = 0; j < 5; j++) {
-                        Files.readAllLines(Path.of("D:\\lecture\\Java-Concurrency-Programming\\Java-Concurrency-Programming\\src\\chapter01\\exam03\\sample.txt"));
+                        Files.readAllLines(Path.of("src/main/java/io/concurrency/chapter01/exam03/sample.txt"));
                         System.out.println("스레드: " + Thread.currentThread().getName() +", " +j); // IO Bound 일때 ContextSwitching 이 일어난다
                     }
 
diff --git a/src/main/java/io/concurrency/chapter01/exam03/README.md b/src/main/java/io/concurrency/chapter01/exam03/README.md
new file mode 100644
index 0000000..487cb15
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter01/exam03/README.md
@@ -0,0 +1,7 @@
+# CPUBoundExample & IOBoundExample
+
+CPU 바운드와 I/O 바운드는 병렬성과 동시성에서 약간의 차이가 있음
+
+CPU 바운드의 경우 CPU Burst, 즉 CPU 치중 작업이 많기 때문에 최대한 코어 수와 비슷하게 스레드 수를 생성해서 병렬성의 이점을 볼 수 있도록 구성하는 것이 좋음
+
+I/O 바운드의 경우 I/O Burst, 즉 CPU 치중 작업이 많지 않기 때문에 I/O 작업을 만나 CPU가 연산 작업을 하지 않는 상태가 많이 발생함. 따라서 이 때, 놀고 있는 CPU에게 (스레드를 할당할 수 있도록) 동시성의 이점을 볼 수 있도록 구성하는 것이 좋음
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter02/exam01/AnonymousRunnableClassExample.java b/src/main/java/io/concurrency/chapter02/exam01/AnonymousRunnableClassExample.java
index 2b47744..b96d74d 100644
--- a/src/main/java/io/concurrency/chapter02/exam01/AnonymousRunnableClassExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam01/AnonymousRunnableClassExample.java
@@ -12,5 +12,12 @@ public void run() {
 
         thread.start();
 
+        Thread ywThread = new Thread(new Runnable() {
+            public void run() {
+                System.out.println(Thread.currentThread().getName() + " : yw스레드 실행중..");
+            }
+        });
+        ywThread.start();
+
     }
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam01/AnonymousThreadClassExample.java b/src/main/java/io/concurrency/chapter02/exam01/AnonymousThreadClassExample.java
index 55c0d23..2a6536c 100644
--- a/src/main/java/io/concurrency/chapter02/exam01/AnonymousThreadClassExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam01/AnonymousThreadClassExample.java
@@ -11,5 +11,18 @@ public void run() {
         };
 
         thread.start();
+
+
+        Thread ywThread = new Thread() {
+            public void run() {
+                System.out.println(Thread.currentThread().getName() + " : yw 스레드 실행중 ..");
+            }
+        };
+
+        ywThread.start();
+
     }
+
+
+
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam01/ExtendThreadExample.java b/src/main/java/io/concurrency/chapter02/exam01/ExtendThreadExample.java
index 6b41e7e..c0f58ce 100644
--- a/src/main/java/io/concurrency/chapter02/exam01/ExtendThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam01/ExtendThreadExample.java
@@ -5,9 +5,19 @@ public static void main(String[] args) {
 
         MyThread myThread = new MyThread();
         myThread.start();
+
+        YwThread thread = new YwThread();
+        thread.start();
     }
  }
 
+ class YwThread extends Thread{
+     @Override
+     public void run() {
+         System.out.println(Thread.currentThread().getName() + " : 스레드 실행 중..");
+     }
+ }
+
  class MyThread extends Thread{
      @Override
      public void run() {
diff --git a/src/main/java/io/concurrency/chapter02/exam01/ImplementRunnableExample.java b/src/main/java/io/concurrency/chapter02/exam01/ImplementRunnableExample.java
index b49dbbe..c7b5f02 100644
--- a/src/main/java/io/concurrency/chapter02/exam01/ImplementRunnableExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam01/ImplementRunnableExample.java
@@ -6,9 +6,18 @@ public static void main(String[] args) {
         MyRunnable task = new MyRunnable();
         Thread thread = new Thread(task);
         thread.start();
+
+        YwRunnable yw = new YwRunnable();
+        Thread thread2 = new Thread(yw);
+        thread2.start();
     }
 }
 
+class YwRunnable implements Runnable{
+    public void run(){
+        System.out.println(Thread.currentThread().getName() + " : 실행 중..");
+    }
+}
 class MyRunnable implements Runnable{
 
     @Override
diff --git a/src/main/java/io/concurrency/chapter02/exam01/LambdaThreadExample.java b/src/main/java/io/concurrency/chapter02/exam01/LambdaThreadExample.java
index a4b6aa8..73fe625 100644
--- a/src/main/java/io/concurrency/chapter02/exam01/LambdaThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam01/LambdaThreadExample.java
@@ -4,5 +4,9 @@ public class LambdaThreadExample {
     public static void main(String[] args) {
         Thread thread = new Thread(() -> System.out.println(Thread.currentThread().getName() + ": 스레드 실행 중.."));
         thread.start();
+
+        Thread ywThread = new Thread(() -> System.out.println(Thread.currentThread().getName() + " : yw newww 스레드 실행"));
+        ywThread.start();
+
     }
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam02/MultiThreadAppTerminatedExample.java b/src/main/java/io/concurrency/chapter02/exam02/MultiThreadAppTerminatedExample.java
index 5d30950..69a1206 100644
--- a/src/main/java/io/concurrency/chapter02/exam02/MultiThreadAppTerminatedExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam02/MultiThreadAppTerminatedExample.java
@@ -4,7 +4,7 @@ public class MultiThreadAppTerminatedExample {
     public static void main(String[] args) {
 
         for (int i = 0; i < 3; i++) {
-            Thread thread = new Thread(new ThreadStackExample.MyRunnable(i));
+            Thread thread = new Thread(new MyRunnable(i));
             thread.start();
         }
 
diff --git a/src/main/java/io/concurrency/chapter02/exam02/README.md b/src/main/java/io/concurrency/chapter02/exam02/README.md
new file mode 100644
index 0000000..8ca60ca
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter02/exam02/README.md
@@ -0,0 +1,84 @@
+# ThreadStartRunExample
+
+스레드는 start()를 통해서 실행시켜야 한다!<br>
+run()은 JVM이 자동으로 호출하는 실행 메서드이기 때문에 직접 스레드에 run()을 호출해주게 되면 그냥 메인 스레드 스택에 run()이 생성되며, 별도의 스레드가 생성되지 않는다<br>
+
+```java
+
+public static void main(String[] args) {
+
+    Thread thread1 = new Thread(new Runnable() {
+        @Override
+        public void run() {
+            System.out.println(Thread.currentThread().getName() + " : 스레드 실행중..");
+        }
+    });
+
+    Thread thread2 = new Thread(new Runnable() {
+        @Override
+        public void run() {
+            System.out.println(Thread.currentThread().getName() + " : 스레드 실행중..");
+        }
+    });
+
+    MyRunnable my = new MyRunnable();
+    Thread thread3 = new Thread(my);
+
+    thread1.start();
+    thread2.start();
+    thread3.run();
+
+
+    System.out.println(Thread.currentThread().getName() + ": 메인 스레드 종료");
+}
+
+static class MyRunnable implements Runnable {
+    @Override
+    public void run() {
+        System.out.println(Thread.currentThread().getName() + ": 스레드 실행 중..");
+    }
+}
+
+```
+지금 start()와 run()을 같이 사용해주고 있다<br>
+출력 결과는 다음과 같다
+```java
+Thread-1 :스레드 실행중..
+Thread-0 : 스레드 실행중..
+main: 스레드 실행 중...
+main: 메인 스레드 종료
+Thread-2 : 스레드 실행중..
+```
+ - 스레드는 독립적으로 동작하기 때문에 메인 스레드가 종료된 후에도 새로운 스레드가 생성됨을 확인 가능
+ - thread3.run()을 했기 때문에 main 스레드에서 run()이 동작했음을 확인 가능 (즉 새로운 스레드 생성 x)
+
+# ThreadStackExample
+
+문자열 리터럴은 불변 객체로서, JVM에 힙 영역 내의 String Pool에 저장<br>
+따라서 스레드가 문자열 리터럴 객체를 생성하는 함수를 실행하면, 문자열 객체는 스레드 스택이 아니라 힙에 생성된다<br>
+스레드 스택은 문자열 객체의 참조를 갖게 된다
+ex)
+```java
+private void secondMethod(int localValue) {
+    String objectReference = threadId +" : Hello World";
+    System.out.println(Thread.currentThread().getName() + " : 스레드 ID : "+threadId + " Value : "+localValue);
+}
+```
+
+# MultiThreadAppTerminatedExample
+
+```java
+메인 스레드 종료
+Thread-1: 스레드 실행 중...
+Thread-2: 스레드 실행 중...
+Thread-0: 스레드 실행 중...
+Thread-1 : 스레드 ID : 1, Value:101
+Thread-0 : 스레드 ID : 0, Value:100
+Thread-2 : 스레드 ID : 2, Value:102
+```
+메인 스레드가 먼저 종료되어도 애플리케이션 자체는 종료되지 않는다<br>
+메인 스레드가 생성한 사용자 스레드가 완전히 종료돼야 어플리케이션이 종료된다<br>
+
+# SingleThreadAppTerminatedExample
+
+메인 스레드가 종료되면 어플리케이션 종료
diff --git a/src/main/java/io/concurrency/chapter02/exam02/ThreadStackExample.java b/src/main/java/io/concurrency/chapter02/exam02/ThreadStackExample.java
index 186ed99..0c9b36e 100644
--- a/src/main/java/io/concurrency/chapter02/exam02/ThreadStackExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam02/ThreadStackExample.java
@@ -1,39 +1,35 @@
 package io.concurrency.chapter02.exam02;
 
 public class ThreadStackExample {
+
     public static void main(String[] args) {
 
         for (int i = 0; i < 3; i++) {
             Thread thread = new Thread(new MyRunnable(i));
             thread.start();
         }
-
     }
     static class MyRunnable implements Runnable{
 
         private final int threadId;
-
-        public MyRunnable(int threadId) {
-
+        public MyRunnable(int threadId){
             this.threadId = threadId;
         }
-
         @Override
         public void run() {
-            System.out.println(Thread.currentThread().getName() + ": 스레드 실행 중...");
+            System.out.println(Thread.currentThread().getName() + " : 스레드 실행 중.");
             firstMethod(threadId);
         }
 
         private void firstMethod(int threadId) {
-
             int localValue = threadId + 100;
             secondMethod(localValue);
-
         }
 
         private void secondMethod(int localValue) {
-            String objectReference = threadId + ": Hello World";
-            System.out.println(Thread.currentThread().getName() + " : 스레드 ID : " + threadId + ", Value:" + localValue);
+            String objectReference = threadId +" : Hello World";
+            System.out.println(Thread.currentThread().getName() + " : 스레드 ID : "+threadId + " Value : "+localValue);
         }
     }
+
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam02/ThreadStartRunExample.java b/src/main/java/io/concurrency/chapter02/exam02/ThreadStartRunExample.java
index df13b83..337be91 100644
--- a/src/main/java/io/concurrency/chapter02/exam02/ThreadStartRunExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam02/ThreadStartRunExample.java
@@ -3,20 +3,41 @@
 public class ThreadStartRunExample {
     public static void main(String[] args) {
 
+
+        Thread thread1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println(Thread.currentThread().getName() + " : 스레드 실행중..");
+            }
+        });
+
+
+        thread1.start();
+
         MyRunnable myRunnable = new MyRunnable();
-        Thread thread = new Thread(new Runnable() {
+        Thread thread2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println(Thread.currentThread().getName() + " :스레드 실행중..");
             }
         });
 
-        thread.start();
-//        thread.run();
-//        myRunnable.run();
+        thread2.start();
 
+        myRunnable.run();
+
+        Thread thread3 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println(Thread.currentThread().getName() + " : 스레드 실행중..");
+            }
+        });
+
+        thread3.start();
+        System.out.println(Thread.currentThread().getName() + ": 메인 스레드 종료");
     }
 
+
     static class MyRunnable implements Runnable{
 
         @Override
diff --git a/src/main/java/io/concurrency/chapter02/exam03/BlockedStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/BlockedStateThreadExample.java
index 1d4103e..4e098ac 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/BlockedStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/BlockedStateThreadExample.java
@@ -21,6 +21,7 @@ public static void main(String[] args) throws InterruptedException {
         thread2.start();
         Thread.sleep(100); // thread2가 lock을 기다리는 상태로 대기
         System.out.println("스레드 2 상태: " + thread2.getState()); // BLOCKED
+
     }
 
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam03/NewStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/NewStateThreadExample.java
index 1add97b..cebaae9 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/NewStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/NewStateThreadExample.java
@@ -3,10 +3,10 @@
 public class NewStateThreadExample {
 
     public static void main(String[] args) {
-        Thread thread = new Thread(() -> {
-            System.out.println("스레드 실행 중");
-        });
-        System.out.println("스레드 상태: " + thread.getState()); // NEW
+
+        Thread thread = new Thread(() -> System.out.println("스레드 실행 중"));
+
+        System.out.println("스레드 상태 : "+thread.getState()); //NEW . 일반 객체를 생성한 상태와 같음
     }
 
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam03/RunnableStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/RunnableStateThreadExample.java
index 6d7c16a..1860e51 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/RunnableStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/RunnableStateThreadExample.java
@@ -14,5 +14,6 @@ public static void main(String[] args) throws InterruptedException {
             }
         });
         thread.start();
+
     }
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam03/TerminatedStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/TerminatedStateThreadExample.java
index 71ffcc3..f2c8a20 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/TerminatedStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/TerminatedStateThreadExample.java
@@ -7,7 +7,7 @@ public static void main(String[] args) throws InterruptedException {
             System.out.println("스레드 실행 중");
         });
         thread.start();
-        thread.join(); // 스레드가 종료될 때까지 기다림
+        thread.join(); // 메인 스레드가 종료될 때까지 기다림
         System.out.println("스레드 상태: " + thread.getState()); // TERMINATED
     }
 
diff --git a/src/main/java/io/concurrency/chapter02/exam03/ThreadLifecycleExample.java b/src/main/java/io/concurrency/chapter02/exam03/ThreadLifecycleExample.java
index 7ee1d76..887bbc8 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/ThreadLifecycleExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/ThreadLifecycleExample.java
@@ -72,7 +72,7 @@ public static void main(String[] args) throws InterruptedException {
          * TERMINATED 상태
          */
         newThread.start();
-        newThread.join();
+        newThread.join(); //메인 스레드 끝나면 종료
 
         System.out.println("스레드 실행: " + runnableThread.getState());
         System.out.println("스레드 지정된 시간 대기: " + timedWaitingThread.getState());
diff --git a/src/main/java/io/concurrency/chapter02/exam03/TimedWaitingStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/TimedWaitingStateThreadExample.java
index fccf20b..a721c2b 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/TimedWaitingStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/TimedWaitingStateThreadExample.java
@@ -2,17 +2,20 @@
 
 public class TimedWaitingStateThreadExample {
 
-    public static void main(String[] args) throws InterruptedException {
+    public static void main(String[] args) throws InterruptedException{
+
         Thread thread = new Thread(() -> {
             try {
-                Thread.sleep(10000);
+                Thread.sleep(1000);
             } catch (InterruptedException e) {
-                e.printStackTrace();
+                throw new RuntimeException(e);
             }
         });
+
         thread.start();
         Thread.sleep(100);
-        System.out.println("스레드 상태: " + thread.getState()); // TIMED_WAITING
+        System.out.println("스레드 상태 : "+thread.getState());
+
     }
 
 }
diff --git a/src/main/java/io/concurrency/chapter02/exam03/WaitingStateThreadExample.java b/src/main/java/io/concurrency/chapter02/exam03/WaitingStateThreadExample.java
index c630bf6..98a5ece 100644
--- a/src/main/java/io/concurrency/chapter02/exam03/WaitingStateThreadExample.java
+++ b/src/main/java/io/concurrency/chapter02/exam03/WaitingStateThreadExample.java
@@ -3,18 +3,40 @@
 public class WaitingStateThreadExample {
 
     public static void main(String[] args) throws InterruptedException {
-        final Object lock = new Object();
+
+
+        Object lock = new Object();
+
         Thread thread = new Thread(() -> {
             synchronized (lock) {
                 try {
                     lock.wait();
                 } catch (InterruptedException e) {
-                    e.printStackTrace();
+
+
                 }
+
             }
         });
+
         thread.start();
+
         Thread.sleep(100);
-        System.out.println("스레드 상태: " + thread.getState()); // WAITING
+        System.out.println("스레드 상태 : "+thread.getState());
+
+        //        final Object lock = new Object();
+//        Thread thread = new Thread(() -> {
+//            synchronized (lock) {
+//                try {
+//                    lock.wait();
+//                } catch (InterruptedException e) {
+//                    e.printStackTrace();
+//                }
+//            }
+//        });
+//        thread.start();
+//        Thread.sleep(100);
+//        System.out.println("스레드 상태: " + thread.getState()); // WAITING
+//
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam01/BasicSleepExample.java b/src/main/java/io/concurrency/chapter03/exam01/BasicSleepExample.java
index 0f57ae5..c3beec3 100644
--- a/src/main/java/io/concurrency/chapter03/exam01/BasicSleepExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam01/BasicSleepExample.java
@@ -2,12 +2,12 @@
 
 public class BasicSleepExample {
     public static void main(String[] args) {
-        try {
+        try{
             System.out.println("2초 후에 메시지가 출력됩니다");
             Thread.sleep(2000);
             System.out.println("Hello World");
 
-        } catch (InterruptedException e) {
+        }catch (InterruptedException e){
             throw new RuntimeException(e);
         }
     }
diff --git a/src/main/java/io/concurrency/chapter03/exam01/InterruptSleepExample.java b/src/main/java/io/concurrency/chapter03/exam01/InterruptSleepExample.java
index d2c4472..1e0ecea 100644
--- a/src/main/java/io/concurrency/chapter03/exam01/InterruptSleepExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam01/InterruptSleepExample.java
@@ -18,8 +18,10 @@ public static void main(String[] args) throws InterruptedException {
 
         sleepingThread.start();
 
+        //메인 스레드를 1초 정도 쉬게 한 다음
         Thread.sleep(1000);
-//
+
+        //메인 스레드가 sleepingThread에 대해 인터럽트 발생!!
         sleepingThread.interrupt();
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam01/LoopSleepExample.java b/src/main/java/io/concurrency/chapter03/exam01/LoopSleepExample.java
index 0fc7821..1963319 100644
--- a/src/main/java/io/concurrency/chapter03/exam01/LoopSleepExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam01/LoopSleepExample.java
@@ -12,6 +12,6 @@ public static void main(String[] args) {
                 throw new RuntimeException(e);
             }
         }
-
+        System.out.println("Thread.currentThread().getState() = " + Thread.currentThread().getState());
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam01/MultiThreadSleepExample.java b/src/main/java/io/concurrency/chapter03/exam01/MultiThreadSleepExample.java
index 598ed04..4f1b7f0 100644
--- a/src/main/java/io/concurrency/chapter03/exam01/MultiThreadSleepExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam01/MultiThreadSleepExample.java
@@ -3,12 +3,12 @@
 public class MultiThreadSleepExample {
     public static void main(String[] args) {
 
+
         Thread thread1 = new Thread(() -> {
             try {
                 System.out.println("1초 후에 메시지가 출력됩니다");
                 Thread.sleep(1000);
-                System.out.println("스레드 1이 깨어났습니다.");
-
+                System.out.println("스레드 1이 깨어났습니다");
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -16,10 +16,9 @@ public static void main(String[] args) {
 
         Thread thread2 = new Thread(() -> {
             try {
-                System.out.println("2초 후에 메시지가 출력됩니다");
+                System.out.println("2초 후에 메시지가 출력 됩니다");
                 Thread.sleep(2000);
-                System.out.println("스레드 2가 깨어났습니다.");
-
+                System.out.println("스레드 2가 깨어났습니다");
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -28,7 +27,35 @@ public static void main(String[] args) {
         thread1.start();
         thread2.start();
 
-        System.out.println("여기는 메인입니다.");
+        System.out.println("여기는 메인 스레드입니다");
+
+
+//        Thread thread1 = new Thread(() -> {
+//            try {
+//                System.out.println("1초 후에 메시지가 출력됩니다");
+//                Thread.sleep(1000);
+//                System.out.println("스레드 1이 깨어났습니다.");
+//
+//            } catch (InterruptedException e) {
+//                throw new RuntimeException(e);
+//            }
+//        });
+//
+//        Thread thread2 = new Thread(() -> {
+//            try {
+//                System.out.println("2초 후에 메시지가 출력됩니다");
+//                Thread.sleep(2000);
+//                System.out.println("스레드 2가 깨어났습니다.");
+//
+//            } catch (InterruptedException e) {
+//                throw new RuntimeException(e);
+//            }
+//        });
+//
+//        thread1.start();
+//        thread2.start();
+//
+//        System.out.println("여기는 메인입니다.");
 
 
     }
diff --git a/src/main/java/io/concurrency/chapter03/exam01/README.md b/src/main/java/io/concurrency/chapter03/exam01/README.md
new file mode 100644
index 0000000..4edacc0
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter03/exam01/README.md
@@ -0,0 +1,29 @@
+# InterruptSleepExample
+
+```java
+public static void main(String[] args) throws InterruptedException {
+
+        Thread sleepingThread = new Thread(() -> {
+            try {
+                System.out.println("20초 동안 잠듭니다. 인터럽트되지 않는다면 계속 잠들어 있을 것입니다.");
+
+                Thread.sleep(20000); // 스레드는 지정된 시간 동안 잠듭니다
+
+                System.out.println("인터럽트 없이 잠에서 깨었습니다.");
+
+            } catch (InterruptedException e) {
+                System.out.println("잠들어 있는 동안 인터럽트 되었습니다!");
+            }
+        });
+
+        sleepingThread.start();
+
+        //메인 스레드를 1초 정도 쉬게 한 다음
+        Thread.sleep(1000);
+
+        //메인 스레드가 sleepingThread에 대해 인터럽트 발생!!
+        sleepingThread.interrupt();
+    }
+```
+- 메인 함수 내에서 실행된 Thread.sleep()은 메인 스레드를 일시 중지
+- 반면 스레드 객체 내에서 람다 표현식이나 익명 클래스를 통해 생성된 별도의 실행 블럭 내에서 sleep()을 걸면, 그 실행 블럭을 수행하는 스레드가 일시 중지
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter03/exam02/BasicJoinExample.java b/src/main/java/io/concurrency/chapter03/exam02/BasicJoinExample.java
index 6c42e88..2fd9f62 100644
--- a/src/main/java/io/concurrency/chapter03/exam02/BasicJoinExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam02/BasicJoinExample.java
@@ -2,9 +2,9 @@
 
 public class BasicJoinExample {
 
-    public static void main(String[] args) {
+    public static void main(String[] args) { //메인 함수의 메인 스레드가 일종의 부모 스레드
 
-        Thread thread = new Thread(() -> {
+        Thread thread = new Thread(() -> { //메인 스레드의 자식 스레드
             try {
                 System.out.println("스레드가 3초 동안 작동합니다.");
                 Thread.sleep(5000);
@@ -18,14 +18,16 @@ public static void main(String[] args) {
 
         System.out.println("메인 스레드가 다른 스레드의 완료를 기다립니다.");
 
-        try {
 
-            thread.join();
+        try {
+            //메인 스레드가 대상(자식) 스레드에게 join()을 걸고 있다!
+            thread.join(); //자식 스레드가 완료될 때까지 대기
 
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
 
         System.out.println("메인 스레드가 계속 진행합니다");
+
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam02/InterruptedJoinExample.java b/src/main/java/io/concurrency/chapter03/exam02/InterruptedJoinExample.java
index 363d978..e04936f 100644
--- a/src/main/java/io/concurrency/chapter03/exam02/InterruptedJoinExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam02/InterruptedJoinExample.java
@@ -9,12 +9,12 @@ public static void main(String[] args) {
         Thread longRunningThread = new Thread(() -> {
             try {
                 for (int i = 0; i < 10; i++) {
-                    System.out.println("긴 작업 스레드가 계속 실행 중...");
+                    System.out.println("긴 스레드가 계속 실행 중...");
                     Thread.sleep(1000);
                 }
             } catch (InterruptedException e) {
                 mainThread.interrupt();
-                System.out.println("긴 작업 스레드가 인터럽트 되었습니다.");
+                System.out.println("긴 작업 스레드가 인터럽트 되었습니다");
             }
         });
 
@@ -22,7 +22,7 @@ public static void main(String[] args) {
 
         Thread interruptingThread = new Thread(() -> {
             try {
-                System.out.println("인터럽트 스레드가 2초 후에 긴 작업 스레드를 인터럽트 합니다.");
+                System.out.println("인터럽트 스레드가 2초 후에 긴 작업 스레드를 인터럽트 합니다");
                 Thread.sleep(2000);
                 longRunningThread.interrupt();
             } catch (InterruptedException e) {
@@ -32,15 +32,54 @@ public static void main(String[] args) {
 
         interruptingThread.start();
 
-
-        try {
+        //메인 스레드가 조인에서 빠져나오는 것을 확인하자
+        //즉 메인 스레드에게 인터럽트를 걸어야 한다!!
+        try{
             System.out.println("메인 스레드가 긴 작업 스레드의 완료를 기다립니다.");
             longRunningThread.join();
             System.out.println("메인 스레드 작업 완료");
-
-        } catch (InterruptedException e) {
-            System.out.println("메인 스레드가 인터럽트 되었습니다.");
-            throw new RuntimeException(e);
+        }catch (InterruptedException e){
+            System.out.println("메인 스레드가 인터럽트 되었습니다");
         }
+
+
+//        Thread mainThread = Thread.currentThread();
+//
+//        Thread longRunningThread = new Thread(() -> {
+//            try {
+//                for (int i = 0; i < 10; i++) {
+//                    System.out.println("긴 작업 스레드가 계속 실행 중...");
+//                    Thread.sleep(1000);
+//                }
+//            } catch (InterruptedException e) {
+//                mainThread.interrupt();
+//                System.out.println("긴 작업 스레드가 인터럽트 되었습니다.");
+//            }
+//        });
+//
+//        longRunningThread.start();
+//
+//        Thread interruptingThread = new Thread(() -> {
+//            try {
+//                System.out.println("인터럽트 스레드가 2초 후에 긴 작업 스레드를 인터럽트 합니다.");
+//                Thread.sleep(2000);
+//                longRunningThread.interrupt();
+//            } catch (InterruptedException e) {
+//                throw new RuntimeException(e);
+//            }
+//        });
+//
+//        interruptingThread.start();
+//
+//
+//        try {
+//            System.out.println("메인 스레드가 긴 작업 스레드의 완료를 기다립니다.");
+//            longRunningThread.join();
+//            System.out.println("메인 스레드 작업 완료");
+//
+//        } catch (InterruptedException e) {
+//            System.out.println("메인 스레드가 인터럽트 되었습니다.");
+//            throw new RuntimeException(e);
+//        }
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam02/MultiThreadJoinExample.java b/src/main/java/io/concurrency/chapter03/exam02/MultiThreadJoinExample.java
index 4c32dac..965f088 100644
--- a/src/main/java/io/concurrency/chapter03/exam02/MultiThreadJoinExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam02/MultiThreadJoinExample.java
@@ -31,6 +31,7 @@ public static void main(String[] args) throws InterruptedException {
         thread1.join();
         thread2.join();
 
+
         System.out.println("메인 스레드가 계속 진행합니다");
 
     }
diff --git a/src/main/java/io/concurrency/chapter03/exam02/README.md b/src/main/java/io/concurrency/chapter03/exam02/README.md
new file mode 100644
index 0000000..3cfc84b
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter03/exam02/README.md
@@ -0,0 +1,51 @@
+# InterruptedJoinExample
+
+조인을 호출하는 스레드와, 조인의 대상이 되는 스레드와, 조인에서 인터럽트 되는 스레드를 잘 구분 지어야 한다
+
+가정)<br>
+메인 스레드 -> 조인을 호출하는 스레드 <br>
+스레드 1 -> 조인의 대상이 되는 스레드. 인터럽트 되면 자신을 호출한 메서드를 인터럽트 시킴<br>
+스레드 2 -> 스레드 1을 인터럽트 시키는 스레드<br>
+
+
+```java
+
+try{
+    //메인 스레드 코드 블럭
+    스레드1.start(); // 스레드 1 실행
+    
+    스레드1.join(); //메인 스레드가 일시 중지 상태에 들어감
+
+    스레드2.start(); //스레드 1을 인터럽트 시키는 스레드 실행
+
+    //스레드 1 인터럽트 발생 -> InterruptedException 발생
+
+    //스레드 1의 InterruptedException에 의해 메인 스레드 인터럽트
+
+    // 메인 스레드의 인터럽트 발생 -> InterruptedException 발생
+
+    System.out.println("메인 스레드가 작업이 정상적으로 종료되었습니다");
+    
+    }catch (InterruptedException e){
+        System.out.println("메인 스레드가 인터럽트 되었습니다"); //해당 문구가 출력됨
+    }
+```
+이에 따라 스레드 1은 메인 스레드를 인터럽트하는 코드를 갖고 있어야 한다
+
+```java
+        Thread mainThread = Thread.currentThread();
+
+        Thread longRunningThread = new Thread(() -> {
+            try {
+                for (int i = 0; i < 10; i++) {
+                    System.out.println("긴 스레드가 계속 실행 중...");
+                    Thread.sleep(1000);
+                }
+            } catch (InterruptedException e) {
+                mainThread.interrupt();
+                System.out.println("긴 작업 스레드가 인터럽트 되었습니다");
+            }
+        });
+```
+
+### join을 호출한 스레드가 인터럽트를 받아야 wait()에서 빠져나오고 Runnable로 전환
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter03/exam03/InterruptExample.java b/src/main/java/io/concurrency/chapter03/exam03/InterruptExample.java
index 8180d3c..b68da74 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/InterruptExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/InterruptExample.java
@@ -18,8 +18,8 @@ public static void main(String[] args) throws InterruptedException {
         Thread.sleep(1000);
         thread1.start();
 
-        thread1.join();
-        thread2.join();
+        thread1.join(); //메인 스레드는 thread1 작업이 끝날 때 까지 대기
+        thread2.join(); //메인 스레드는 thread2 작업이 끝날 때 까지 대기
 
         System.out.println("모든 스레드 작업 완료");
     }
diff --git a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample1.java b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample1.java
index ccd3caf..5991681 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample1.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample1.java
@@ -7,16 +7,17 @@ public static void main(String[] args) {
                 System.out.println("스레드가 작동 중입니다.");
             }
             System.out.println("스레드가 인터럽트 되었습니다.");
+            //인터럽트 상태를 초기화 시킴
             System.out.println("인터럽트 상태: " + Thread.currentThread().isInterrupted());
         });
         thread.start();
 
         try {
-            Thread.sleep(1000);
+            Thread.sleep(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
-        thread.interrupt();
+        thread.interrupt(); //메인스레드에서 thread에게 인터럽트 발생
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample2.java b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample2.java
index 5830714..715434c 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample2.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample2.java
@@ -13,6 +13,7 @@ public static void main(String[] args) {
             for (int i = 0; i < 5; i++) {
                 System.out.println("스레드 1 작동 중");
                 if (i == 2) {
+                    System.out.println("i = " + i);
                     thread2.interrupt();
                 }
                 try {
diff --git a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample3.java b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample3.java
index bbb0033..23aab49 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample3.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExample3.java
@@ -2,6 +2,8 @@
 
 public class InterruptedExample3 {
     public static void main(String[] args) {
+
+
         Thread thread = new Thread(() -> {
             while (true) {
                 System.out.println("스레드 작동 중");
diff --git a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExceptionExample.java b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExceptionExample.java
index d404071..ef2affe 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/InterruptedExceptionExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/InterruptedExceptionExample.java
@@ -2,7 +2,8 @@
 
 public class InterruptedExceptionExample {
     public static void main(String[] args) throws InterruptedException {
-        Thread thread = new Thread(() -> {
+
+        Thread thread1 = new Thread(() -> {
             try {
                 System.out.println("인터럽트 상태 1: " + Thread.currentThread().isInterrupted());
                 Thread.sleep(5000);
@@ -14,7 +15,7 @@ public static void main(String[] args) throws InterruptedException {
             }
         });
 
-        thread.start();
+        thread1.start();
 
         try {
             Thread.sleep(2000);
@@ -22,8 +23,8 @@ public static void main(String[] args) throws InterruptedException {
             e.printStackTrace();
         }
 
-        thread.interrupt();
-        thread.join();
-        System.out.println("인터럽트 상태 3: " + thread.isInterrupted());
+        thread1.interrupt();
+        thread1.join(); //메인 스레드가 thread1에 조인. 즉 thread1의 작업이 끝날 때까지 대기
+        System.out.println("인터럽트 상태 3: " + thread1.isInterrupted());
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam03/IsInterruptedExample.java b/src/main/java/io/concurrency/chapter03/exam03/IsInterruptedExample.java
index e1104bd..8937aa9 100644
--- a/src/main/java/io/concurrency/chapter03/exam03/IsInterruptedExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam03/IsInterruptedExample.java
@@ -3,11 +3,11 @@
 public class IsInterruptedExample {
     public static void main(String[] args) {
         Thread thread = new Thread(() -> {
-            while (!Thread.currentThread().isInterrupted()) {
-                System.out.println("스레드가 작동 중입니다.");
+            while(!Thread.currentThread().isInterrupted()){
+                System.out.println("스레드가 작동 중입니다..");
             }
-            System.out.println("스레드가 인터럽트 되었습니다.");
-            System.out.println("인터럽트 상태: " + Thread.currentThread().isInterrupted());
+            System.out.println("스레드가 인터럽트 되었습니다");
+            System.out.println("인터럽트 상태 : "+Thread.currentThread().isInterrupted());
         });
         thread.start();
 
@@ -17,6 +17,6 @@ public static void main(String[] args) {
             e.printStackTrace();
         }
 
-        thread.interrupt();
+        thread.interrupt(); //메인 스레드가 thread에게 인터럽트 발생시킴
     }
 }
diff --git a/src/main/java/io/concurrency/chapter03/exam04/CurrentThreadExample.java b/src/main/java/io/concurrency/chapter03/exam04/CurrentThreadExample.java
index 406291d..db5e3c2 100644
--- a/src/main/java/io/concurrency/chapter03/exam04/CurrentThreadExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam04/CurrentThreadExample.java
@@ -3,15 +3,16 @@
 public class CurrentThreadExample {
     public static void main(String[] args) {
 
+
         // 현재 실행 중인 스레드를 가져와 이름 출력
-        System.out.println("현재 스레드: " + Thread.currentThread());
-        System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
+        System.out.println("현재 스레드(main): " + Thread.currentThread());
+        System.out.println("현재 스레드 이름(main): " + Thread.currentThread().getName());
 
         // Thread 객체를 사용하여 스레드 생성 및 시작
         Thread thread1 = new Thread() {
             @Override
             public void run() {
-                System.out.println("현재 스레드: " + Thread.currentThread());
+                System.out.println("현재 스레드 (Thread 객체 사용): " + this);
                 // 현재 스레드의 이름을 출력
                 System.out.println("현재 스레드 이름 (Thread 객체 사용): " + getName());
             }
@@ -22,11 +23,12 @@ public void run() {
         thread2.start();
     }
 
+
     static class ThreadName implements Runnable {
 
         @Override
         public void run() {
-            System.out.println("현재 스레드: " + Thread.currentThread());
+            System.out.println("현재 스레드 (Runnable 사용): " + Thread.currentThread());
             // 현재 스레드의 이름을 출력
             System.out.println("현재 스레드 이름 (Runnable 사용): " + Thread.currentThread().getName());
         }
diff --git a/src/main/java/io/concurrency/chapter03/exam04/README.md b/src/main/java/io/concurrency/chapter03/exam04/README.md
new file mode 100644
index 0000000..003615c
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter03/exam04/README.md
@@ -0,0 +1,72 @@
+# ThreadNamingExample
+
+```java
+public class ThreadNamingExample {
+    public static void main(String[] args) throws InterruptedException {
+
+
+        // 스레드 이름을 생성자에 전달하여 설정
+        Thread myThread = new Thread(() -> {
+            System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
+        }, "myThread");
+        myThread.start();
+
+        // setName() 메서드를 사용하여 스레드 이름 설정
+        Thread yourThread = new Thread(() -> {
+            System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
+        });
+        yourThread.setName("yourThread");
+        yourThread.start();
+
+        // 여러 개의 스레드를 생성하여 기본 스레드 이름을 출력
+        for (int i = 0; i < 5; i++) {
+            Thread defaultThread = new Thread(() -> {
+                System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
+            });
+            defaultThread.start();
+        }
+
+        Thread.sleep(2000);
+    }
+}
+```
+- 스레드의 이름을 지정하지 않으면 Thread-0...Thread-n까지 이렇게 0부터 시작해서 이름을 부여하는데,
+- 위 경우 yourThread는 처음에 이름을 지정하지 않고 생성되었기 떄문에 Thread-0이라는 이름을 가지는데, setNamed()을 통해 이름을 수정함
+- 따라서 이미 한번 nextThreadNum()이 호출되었기 때문에 threadSeqNumber가 1의 값을 갖고 있고, 이후 defaultThread는 Thread-1부터 시작해서 이름을 부여받게 됨
+- 생성자에 이름을 같이 전달하면 nextThreadNum()이 호출되지 않고 바로 이름 부여됨
+
+# CurrentThreadExample
+스레드의 이름을 가져오는 3가지 경우를 살펴본다
+
+1. 현재 실행 중인 스레드 정보 가져오기
+```java
+// 현재 실행 중인 스레드를 가져와 이름 출력
+System.out.println("현재 스레드(main): " + Thread.currentThread());
+System.out.println("현재 스레드 이름(main): " + Thread.currentThread().getName());
+```
+2. Thread 객체 내부에서 스레드 정보 가져오기
+```java
+    Thread thread1 = new Thread() {
+    @Override
+    public void run() {
+        System.out.println("현재 스레드 (Thread 객체 사용): " + this);
+        // 현재 스레드의 이름을 출력
+        System.out.println("현재 스레드 이름 (Thread 객체 사용): " + getName());
+    }
+};
+```
+  - 위와 같은 경우는, 해당 스레드 내부에서 이름을 가져오는 것이기 때문에 바로 this 자체가 현재 스레드이다
+3. Runnable 내부에서 스레드 정보 가져오기
+```java
+    Thread thread2 = new Thread(new ThreadName());
+
+    static class ThreadName implements Runnable {
+
+        @Override
+        public void run() {
+            System.out.println("현재 스레드 (Runnable 사용): " + Thread.currentThread());
+            System.out.println("현재 스레드 이름 (Runnable 사용): " + Thread.currentThread().getName());
+        }
+    }
+```
+  - Runnable은 여러 스레드 간 사용 가능하기 때문에 반드시 Thread.currentThread()를 지칭해서 현재 CPU를 할당받은 스레드 정보를 가져오도록 참조해야한다
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter03/exam04/ThreadNamingExample.java b/src/main/java/io/concurrency/chapter03/exam04/ThreadNamingExample.java
index b8bd66c..087bf60 100644
--- a/src/main/java/io/concurrency/chapter03/exam04/ThreadNamingExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam04/ThreadNamingExample.java
@@ -3,6 +3,7 @@
 public class ThreadNamingExample {
     public static void main(String[] args) throws InterruptedException {
 
+
         // 스레드 이름을 생성자에 전달하여 설정
         Thread myThread = new Thread(() -> {
             System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
@@ -12,10 +13,11 @@ public static void main(String[] args) throws InterruptedException {
         // setName() 메서드를 사용하여 스레드 이름 설정
         Thread yourThread = new Thread(() -> {
             System.out.println("현재 스레드 이름: " + Thread.currentThread().getName());
-        },"yourThread");
-//        yourThread.setName("yourThread");
+        });
+        yourThread.setName("yourThread");
         yourThread.start();
 
+
         // 여러 개의 스레드를 생성하여 기본 스레드 이름을 출력
         for (int i = 0; i < 5; i++) {
             Thread defaultThread = new Thread(() -> {
diff --git a/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityAPIExample.java b/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityAPIExample.java
index 3f79304..d9b6a6e 100644
--- a/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityAPIExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityAPIExample.java
@@ -3,11 +3,11 @@
 public class ThreadPriorityAPIExample {
     public static void main(String[] args) {
 
+
         Thread thread = new Thread();
         System.out.println("기본우선순위: "  + thread.getPriority());
         thread.start();
 
-
         Thread minThread = new Thread(() -> {
             System.out.println("최소 우선순위 :" + Thread.currentThread().getPriority());
         });
diff --git a/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityExample.java b/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityExample.java
index 1b4882b..11b7946 100644
--- a/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityExample.java
+++ b/src/main/java/io/concurrency/chapter03/exam05/ThreadPriorityExample.java
@@ -8,13 +8,13 @@ public static void main(String[] args) throws InterruptedException {
         CountingThread normThread = new CountingThread("우선 순위가 기본인 스레드", Thread.NORM_PRIORITY);
         CountingThread minThread = new CountingThread("우선 순위가 낮은 스레드", Thread.MIN_PRIORITY);
 
-        maxThread.start();
         normThread.start();
+        maxThread.start();
         minThread.start();
 
-        maxThread.join();
-        normThread.join();
-        minThread.join();
+        normThread.join();//메인 스레드가 normThread가 끝날 때까지 대기
+        minThread.join();//메인 스레드가 minThread가 끝날 때까지 대기
+        maxThread.join(); //메인 스레드가 maxThread가 끝날 때까지 대기
 
         System.out.println("작업 완료");
 
diff --git a/src/main/java/io/concurrency/chapter04/exam01/DefaultExceptionHandlerExample.java b/src/main/java/io/concurrency/chapter04/exam01/DefaultExceptionHandlerExample.java
index 2f3f6d4..9316796 100644
--- a/src/main/java/io/concurrency/chapter04/exam01/DefaultExceptionHandlerExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam01/DefaultExceptionHandlerExample.java
@@ -8,6 +8,7 @@ public class DefaultExceptionHandlerExample {
     public static void main(String[] args) {
 
         // 모든 스레드의 예외에 대한 기본 핸들러 설정
+        //이 핸들러를 호출하는 것은 메인 스레드! 따라서 메인(외부)에서 여러 스레드의 전역적인 예외 캐치 가능하다
         Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
             @Override
             public void uncaughtException(Thread t, Throwable e) {
diff --git a/src/main/java/io/concurrency/chapter04/exam01/README.md b/src/main/java/io/concurrency/chapter04/exam01/README.md
new file mode 100644
index 0000000..1376eec
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter04/exam01/README.md
@@ -0,0 +1,77 @@
+# UncaughtException
+
+run() 메서드는 스레드 예외를 캐치하지 못하기 떄문에 스레드에서 발생한 예외를 캐치하려면 UncaughtExceptionHandler를 사용해야 한다
+
+### setDefaultUncaughtExceptionHandler
+- static 메서드로 전역적으로 모든 스레드의 예외를 캐치함
+- 메인 스레드에서 다른 스레드들의 예외를 캐치하는 것 가능 -> 즉 외부에서 여러 스레드들의 예외 캐치 가능!!
+```java
+        // 모든 스레드의 예외에 대한 기본 핸들러 설정
+        //이 핸들러를 호출하는 것은 메인 스레드! 따라서 메인(외부)에서 여러 스레드의 전역적인 예외 캐치 가능하다
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName() + " 에서 예외 발생 " + e);
+            }
+        });
+
+        // 예외를 발생시키는 여러 스레드
+        Thread thread1 = new Thread(() -> {
+            throw new RuntimeException("스레드 1 예외!");
+        });
+
+        Thread thread2 = new Thread(() -> {
+            throw new RuntimeException("스레드 2 예외!");
+        });
+
+        thread1.start();
+        thread2.start();
+```
+
+### setUncaughtExceptionHandler
+- 대상 스레드에서 발생하는 UncaughtException을 처리하는 인스턴스 메서드
+- setDefaultUncaughtExceptionHandler보다 우선 순위 높음 -> 따라서 setDefaultUncaughtExceptionHandler를 구현했더라도, 대상 스레드에서 구현한 setUncaughtExceptionHandler이 있다면 이게 실행됨
+```java
+
+private static final Logger LOGGER = Logger.getLogger(UncaughtExceptionHandlerExample.class.getName());
+
+public static void main(String[] args) {
+        Thread thread1 = new Thread(() -> {
+            System.out.println("스레드 1 시작!");
+            throw new RuntimeException("예기치 않은 예외!");
+        });
+
+        Thread thread2 = new Thread(() -> {
+            System.out.println("스레드 2 시작!");
+            throw new RuntimeException("예기치 않은 예외!");
+        });
+
+        thread1.setUncaughtExceptionHandler((t, e) -> {
+            LOGGER.log(Level.SEVERE, t.getName() + "에서 예외 발생 : "+e);
+            sendNotificationToAdmin(e);
+        });
+
+        thread2.setUncaughtExceptionHandler((t, e) -> {
+            LOGGER.log(Level.SEVERE, t.getName()+"에서 예외 발생했긔!!! : "+e);
+            sendNotificationToAdmin(e);
+        });
+
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName()+"에서 발생한 예외 전역적으로 캐치햇긔!! : "+e);
+            }
+        });
+
+        thread1.start();
+        thread2.start();
+    }
+
+    // 알림 서비스를 호출하는 메서드
+    private static void sendNotificationToAdmin(Throwable e) {
+        System.out.println("관리자에게 알림: " + e.getMessage());
+    }
+
+```
+- thread1 예외 발생 시 -> SEVERE: Thread-0에서 예외 발생 : java.lang.RuntimeException: 예기치 않은 예외! 
+- thread2 예외 발생 시 -> SEVERE: Thread-1에서 예외 발생했긔!!! : java.lang.RuntimeException: 예기치 않은 예외! 
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter04/exam01/UncaughtExceptionHandlerExample.java b/src/main/java/io/concurrency/chapter04/exam01/UncaughtExceptionHandlerExample.java
index 1f260e6..be70306 100644
--- a/src/main/java/io/concurrency/chapter04/exam01/UncaughtExceptionHandlerExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam01/UncaughtExceptionHandlerExample.java
@@ -7,22 +7,49 @@ public class UncaughtExceptionHandlerExample {
     private static final Logger LOGGER = Logger.getLogger(UncaughtExceptionHandlerExample.class.getName());
 
     public static void main(String[] args) {
-        Thread thread = new Thread(() -> {
-            System.out.println("스레드 시작!");
+
+
+        Thread thread1 = new Thread(() -> {
+            System.out.println("스레드 1 시작!");
 
             // 예기치 않은 예외 발생
             throw new RuntimeException("예기치 않은 예외!");
         });
 
-        // 스레드의 UncaughtExceptionHandler 설정
-        thread.setUncaughtExceptionHandler((t, e) -> {
-            LOGGER.log(Level.SEVERE, t.getName() + " 에서 예외가 발생했습니다.", e);
+        Thread thread2 = new Thread(() -> {
+            System.out.println("스레드 2 시작!");
+
+            // 예기치 않은 예외 발생
+            throw new RuntimeException("예기치 않은 예외!");
+        });
 
-            // 오류가 발생한 경우 알림 서비스 호출 (예: 이메일 또는 Slack 알림)
+        thread1.setUncaughtExceptionHandler((t, e) -> {
+            LOGGER.log(Level.SEVERE, t.getName() + "에서 예외 발생 : "+e);
             sendNotificationToAdmin(e);
         });
 
-        thread.start();
+        thread2.setUncaughtExceptionHandler((t, e) -> {
+            LOGGER.log(Level.SEVERE, t.getName()+"에서 예외 발생했긔!!! : "+e);
+            sendNotificationToAdmin(e);
+        });
+
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println(t.getName()+"에서 발생한 예외 전역적으로 캐치햇긔!! : "+e);
+            }
+        });
+
+        // 스레드의 UncaughtExceptionHandler 설정
+//        thread.setUncaughtExceptionHandler((t, e) -> {
+//            LOGGER.log(Level.SEVERE, t.getName() + " 에서 예외가 발생했습니다.", e);
+//
+//            // 오류가 발생한 경우 알림 서비스 호출 (예: 이메일 또는 Slack 알림)
+//            sendNotificationToAdmin(e);
+//        });
+
+        thread1.start();
+        thread2.start();
     }
 
     // 알림 서비스를 호출하는 메서드
diff --git a/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample.java b/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample.java
index 86f6a49..f56ffdc 100644
--- a/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample.java
@@ -2,34 +2,64 @@
 
 public class FlagThreadStopExample {
     // volatile 키워드 추가
-   volatile boolean running = true;
-//    boolean running = true;
+   //volatile boolean running = true;
+    static boolean running = true;
+
+//    public void volatileTest() {
+//        new Thread(() -> {
+//            int count = 0;
+//            while (running) {
+//                /*try {
+//                    Thread.sleep(10);
+//                } catch (InterruptedException e) {
+//                    throw new RuntimeException(e);
+//                }*/
+//                count++;
+//            }
+//            System.out.println("Thread 1 종료. Count: " + count);
+//        }).start();
+//
+//        new Thread(() -> {
+//            try {
+//                Thread.sleep(100);
+//            } catch (InterruptedException e) {
+//            }
+//            System.out.println("Thread 2 종료 중..");
+//            running = false;
+//        }).start();
+//    }
+
+    public static void main(String[] args) {
 
-    public void volatileTest() {
         new Thread(() -> {
-            int count = 0;
-            while (running) {
-                /*try {
-                    Thread.sleep(10);
+            int cnt = 0;
+            while(running){
+                try {
+                    Thread.sleep(1); //대기에 빠지면서 문맥 교환 발생.
+                    //이 때, 다음 스레드가 캐시 메모리를 사용하게 하기 위해 이 스레드가 사용중이던 캐시 메모리 내용을 비워줘야 한다
+                    //sleep이 끝나서 다시 이 스레드로 문맥 교환이 발생하게 되면, 이전에 사용중이던 스레드의 캐시 메모리는 마찬가지로 비워진 상태
+                    //따라서 스레드가 사용할 정보를 얻기 위해 메모리에서 정보들을 가져오게 되며, 메모리에는 이전 스레드에서 설정한 정보가 어떤 시점에는 분명히 반영됐을 것이다
+                    //따라서 running 플래그가 false임이 반영되어 종료된다
                 } catch (InterruptedException e) {
                     throw new RuntimeException(e);
-                }*/
-                count++;
+                }
+                cnt++;
             }
-            System.out.println("Thread 1 종료. Count: " + count);
+            System.out.println("스레드 1 종료, cnt : "+cnt);
         }).start();
 
         new Thread(() -> {
             try {
-                Thread.sleep(100);
+                Thread.sleep(500);
             } catch (InterruptedException e) {
+                throw new RuntimeException(e);
             }
-            System.out.println("Thread 2 종료 중..");
-            running = false;
+            System.out.println("스레드 2 종료");
+            running = false; //메모리에 즉시 반영되는 게 아니라, thread2의 캐시 메모리에 반영된다. 어떤 적절한 시점에 이 내용이 메모리에 반영된다
         }).start();
-    }
 
-    public static void main(String[] args) {
-        new FlagThreadStopExample().volatileTest();
+        //new FlagThreadStopExample().volatileTest();
     }
+
+
 }
diff --git a/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample2.java b/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample2.java
index c5ddf0c..2f20b3f 100644
--- a/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample2.java
+++ b/src/main/java/io/concurrency/chapter04/exam02/FlagThreadStopExample2.java
@@ -3,10 +3,12 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class FlagThreadStopExample2 {
+
+    //메인 메모리에서 값을 가져오도록 강제함
     private AtomicBoolean running = new AtomicBoolean(true);
 //    private boolean running = true;
 
-    public void volatileTest() {
+    public void AtomicTest() {
         new Thread(() -> {
             int count = 0;
             while (running.get()) {
@@ -26,6 +28,6 @@ public void volatileTest() {
     }
 
     public static void main(String[] args) {
-        new FlagThreadStopExample2().volatileTest();
+        new FlagThreadStopExample2().AtomicTest();
     }
 }
diff --git a/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample3.java b/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample3.java
index 733489a..ef293e3 100644
--- a/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample3.java
+++ b/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample3.java
@@ -15,7 +15,7 @@ public static void main(String[] args) {
                 // 이 때 interrupt 상태는 초기화 된다.
                 // 그렇기 때문에 다시 interrupt 를 호출해 줘야 한다.
                 System.out.println("인트럽트 상태 2 : " + Thread.currentThread().isInterrupted());
-                Thread.currentThread().interrupt();
+                //Thread.currentThread().interrupt();
             }
             System.out.println("작업 스레드가 중단되었습니다.");
             System.out.println("인트럽트 상태 3 : " + Thread.currentThread().isInterrupted());
diff --git a/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample4.java b/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample4.java
index 6327cef..bad807a 100644
--- a/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample4.java
+++ b/src/main/java/io/concurrency/chapter04/exam02/InterruptedExceptionThreadStopExample4.java
@@ -9,6 +9,7 @@ public static void main(String[] args) {
                     System.out.println("작업 스레드가 실행 중입니다.");
                     System.out.println("인트럽트 상태 1 : " + Thread.currentThread().isInterrupted());
 
+                    //임의적으로 InterruptedException을 날리면 인터럽트 상태가 초기화되지 않는다
                     if(Thread.currentThread().isInterrupted()) throw new InterruptedException("thread is interrupted");
                 }
             } catch (InterruptedException e) {
diff --git a/src/main/java/io/concurrency/chapter04/exam02/IsInterruptedThreadStopExample.java b/src/main/java/io/concurrency/chapter04/exam02/IsInterruptedThreadStopExample.java
index db63ef3..be2db3c 100644
--- a/src/main/java/io/concurrency/chapter04/exam02/IsInterruptedThreadStopExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam02/IsInterruptedThreadStopExample.java
@@ -25,7 +25,7 @@ public static void main(String[] args) throws InterruptedException {
         worker.start();
         stopper.start();
 
-        worker.join();
+        worker.join();// 메인 스레드가 이 스레드의 작업이 완전히 끝났을 때 종료되도록 동기화하려고 사용
         stopper.join();
     }
 }
diff --git a/src/main/java/io/concurrency/chapter04/exam02/REAEME.md b/src/main/java/io/concurrency/chapter04/exam02/REAEME.md
new file mode 100644
index 0000000..16de1b3
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter04/exam02/REAEME.md
@@ -0,0 +1,105 @@
+# FlagThreadStopExample
+
+자바의 스레드와 메모리 가시성 문제를 살펴본다
+
+1) 첫 번째 경우
+```java
+boolean running = true;    
+    new Thread(() -> {
+            int cnt = 0;
+            while(running){
+                cnt++;
+            }
+            System.out.println("스레드 1 종료, cnt : "+cnt);
+        }).start();
+
+        new Thread(() -> {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            System.out.println("스레드 2 종료");
+            running = false;
+        }).start();
+```
+두 번째 스레드에서 running = false를 할당했지만, 스레드 1이 종료되었다는 문구가 출력되지 않는다<br>
+스레드 2의 캐시 메모리에서만 새 값이 할당되고, 메모리에는 아직 반영되지 않았기 때문이다<br>
+이는 어떤 적절한 시점에 메모리에 반영되며, 이 변수가 갱신되는 것을 스레드 1은 즉시 볼 수 없다<br>
+자바 메모리에서는 volatile 키워드가 없는 한, 스레드에서 변경한 값이 다른 스레드에게 보장된 시간 안에 가시화되지 않는다
+
+2) 두 번째 경우
+```java
+boolean running = true;    
+    new Thread(() -> {
+            int cnt = 0;
+            while(running){
+                try {
+                    Thread.sleep(1); 
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                cnt++;
+            }
+            System.out.println("스레드 1 종료, cnt : "+cnt);
+        }).start();
+
+        new Thread(() -> {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            System.out.println("스레드 2 종료");
+            running = false;
+        }).start();
+
+```
+running 변수의 값이 false로 변경된 후 스레드 1이 거의 즉시 종료된다<br>
+이는 스레드 1의 Thread.sleep() 때문이다<br>
+스레드가 일시 정지 되며, 문맥 교환을 유발하고 CPU가 다른 작업을 수행하게 된다<br>
+스레드가 일시 중지 상태일 때, CPU는 다른 스레드를 실행할 수 있는데, 이 과정에서 메모리 캐시가 갱신되거나 메모리와의 동기화가 일어난 것으로 보인다<br>
+따라서 스레드 2에서 스레드 1로 다시 전환될 때, running = false가 메인 메모리에 반영되어 스레드 1이 이를 볼 수 있다
+
+인강에서 말한 내용은 이러함
+```text
+//대기에 빠지면서 문맥 교환 발생.
+//이 때, 다음 스레드가 캐시 메모리를 사용하게 하기 위해 스레드 간 캐시 메모리 전환이 필요하다
+//sleep()이 끝나서 다시 스레드1로 문맥 교환이 발생하게 되면, 이전에 사용중이던 스레드의 캐시 메모리에서 스레드 1을 위한 캐시 메모리로 전환 발생
+//따라서 스레드가 사용할 정보를 얻기 위해 메모리에서 정보들을 가져오게 되며, 메모리에는 이전 스레드에서 설정한 정보가 어떤 시점에는 분명히 반영됐을 것이다
+//따라서 running 플래그가 false임이 반영되어 종료된다
+```
+
++) GPT
+```text
+문맥 교환 과정에서 발생하는 캐시 메모리의 처리는 다음과 같이 진행됩니다:
+
+문맥 교환: 운영 체제는 현재 실행 중인 스레드의 상태(레지스터 상태, 프로그램 카운터 등)를 저장하고, 다음 실행할 스레드의 상태를 복원합니다.
+
+CPU 캐시: 문맥 교환 시 CPU의 캐시 내용은 자동으로 교체될 수 있습니다. 새로운 스레드가 실행될 때 필요한 데이터가 캐시에 없다면, 메모리에서 해당 데이터를 가져와 캐시를 새롭게 채우게 됩니다. 이 과정을 캐시 미스라고 하며, 캐시에 적중하지 않은 요청에 대해 메인 메모리에서 데이터를 읽어야 합니다.
+
+캐시 코히런시: 다중 코어 시스템에서는 여러 코어가 동시에 다른 스레드를 실행할 수 있으며, 이 경우 각 코어의 캐시 간 일관성을 유지하기 위해 캐시 코히런시 메커니즘이 작동합니다.
+```
+
+# InterruptedThreadStopExample4
+```java
+        Thread worker = new Thread(() -> {
+            try {
+                while (true) {
+                    // 스레드의 작업을 수행합니다.
+                    System.out.println("작업 스레드가 실행 중입니다.");
+                    System.out.println("인트럽트 상태 1 : " + Thread.currentThread().isInterrupted());
+
+                    //임의적으로 InterruptedException을 날리면 인터럽트 상태가 초기화되지 않는다
+                    if(Thread.currentThread().isInterrupted()) throw new InterruptedException("thread is interrupted");
+                }
+            } catch (InterruptedException e) {
+                // Thread.currentThread().isInterrupted() 는 interrupt 상태를 유지한다.
+                // 그래서 interrupt() 를 호출할 필요가 없다
+                System.out.println("인트럽트 상태 2 : " + Thread.currentThread().isInterrupted());
+            }
+            System.out.println("작업 스레드가 중단되었습니다.");
+            System.out.println("인트럽트 상태 2 : " + Thread.currentThread().isInterrupted());
+        });
+```
+대기 상태로 전환될 때의 InterruptedException 구현이 아니라, 임의적으로 구현해서 인터럽트 예외를 날리게 되면 인터럽트 상태가 바뀌지 않는다
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter04/exam03/DaemonThreadLifeCycleExample.java b/src/main/java/io/concurrency/chapter04/exam03/DaemonThreadLifeCycleExample.java
index ab99018..e5d444e 100644
--- a/src/main/java/io/concurrency/chapter04/exam03/DaemonThreadLifeCycleExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam03/DaemonThreadLifeCycleExample.java
@@ -1,6 +1,7 @@
 package io.concurrency.chapter04.exam03;
 
 public class DaemonThreadLifeCycleExample {
+
     public static void main(String[] args) throws InterruptedException {
         Thread userThread = new Thread(() -> {
             try {
@@ -22,7 +23,7 @@ public static void main(String[] args) throws InterruptedException {
             }
         });
 
-        daemonThread.setDaemon(true);
+        daemonThread.setDaemon(true); //반드시 스레드 실행 전에 데몬으로 지정해야 함
         daemonThread.setDaemon(false);
 
         userThread.start();
diff --git a/src/main/java/io/concurrency/chapter04/exam03/README.md b/src/main/java/io/concurrency/chapter04/exam03/README.md
new file mode 100644
index 0000000..d21a114
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter04/exam03/README.md
@@ -0,0 +1,13 @@
+## 사용자 스레드
+
+모든 사용자 스레드가 종료되어야 애플리케이션 종료!!
+이 때 메인 스레드가 먼저 종료되든 나중에 종료되든 상관 X
+(메인 스레드도 사용자 스레드니까... 일반적인 사용자 스레드와 다른 점은 JVM이 자동으로 생성한다는 것)
+
+## 부모 스레드 자식 스레드
+사용자 스레드는 사용자 스레드를 낳고
+데몬 스레드는 데몬 스레드를 낳는다
+
+## 스레드 데몬 설정
+- thread.setDaemon(true) 사용
+- 반드시 스레드 실행 전에 설정해야 하며, 실행 중에 데몬으로 설정하면 IllegalThreadStateException 발생!!
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter04/exam03/UserAndDaemonInheritanceExample.java b/src/main/java/io/concurrency/chapter04/exam03/UserAndDaemonInheritanceExample.java
index 7aadbf1..d76969a 100644
--- a/src/main/java/io/concurrency/chapter04/exam03/UserAndDaemonInheritanceExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam03/UserAndDaemonInheritanceExample.java
@@ -1,6 +1,31 @@
 package io.concurrency.chapter04.exam03;
 
 public class UserAndDaemonInheritanceExample {
+
+    public void test(){
+
+
+        new Thread(() ->{
+            new Thread(() -> {
+                System.out.println("사용자 스레드의 자식 스레드 데몬 상태: " + Thread.currentThread().isDaemon());
+            }).start();
+            System.out.println("사용자 스레드의 데몬 상태: "+Thread.currentThread().isDaemon());
+
+        }).start();
+
+
+        Thread daemonThread = new Thread(() -> {
+            new Thread(() -> {
+                System.out.println("데몬 스레드의 자식 스레드 데몬 상태: " + Thread.currentThread().isDaemon());
+            }).start();
+            System.out.println("데몬 스레드의 데몬 상태: " + Thread.currentThread().isDaemon());
+
+        });
+
+        daemonThread.setDaemon(true);
+        daemonThread.start();
+
+    }
     public static void main(String[] args) {
 
         // 사용자 스레드 생성
diff --git a/src/main/java/io/concurrency/chapter04/exam03/UserThreadLifecycleExample.java b/src/main/java/io/concurrency/chapter04/exam03/UserThreadLifecycleExample.java
index 60a2dd8..de81b3c 100644
--- a/src/main/java/io/concurrency/chapter04/exam03/UserThreadLifecycleExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam03/UserThreadLifecycleExample.java
@@ -1,6 +1,7 @@
 package io.concurrency.chapter04.exam03;
 
 public class UserThreadLifecycleExample {
+
     public static void main(String[] args) throws InterruptedException {
         // 사용자 스레드 1 생성
         Thread userThread1 = new Thread(() -> {
@@ -32,8 +33,8 @@ public static void main(String[] args) throws InterruptedException {
         userThread2.start();
 
         // 메인 스레드가 userThread1과 userThread2의 종료를 기다립니다.
-//        userThread1.join();
-//        userThread2.join();
+        userThread1.join();
+        userThread2.join();
 
         System.out.println("모든 사용자 스레드가 종료되었습니다. 메인 스레드 종료.");
     }
diff --git a/src/main/java/io/concurrency/chapter04/exam04/NestedThreadGroupExample.java b/src/main/java/io/concurrency/chapter04/exam04/NestedThreadGroupExample.java
index 3cd20c3..d932776 100644
--- a/src/main/java/io/concurrency/chapter04/exam04/NestedThreadGroupExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam04/NestedThreadGroupExample.java
@@ -1,6 +1,7 @@
 package io.concurrency.chapter04.exam04;
 
 public class    NestedThreadGroupExample {
+
     public static void main(String[] args) throws InterruptedException {
 
         // 최상위 스레드 그룹 생성
@@ -9,18 +10,27 @@ public static void main(String[] args) throws InterruptedException {
         // 최상위 스레드 그룹 내부에 하위 스레드 그룹 생성
         ThreadGroup subGroup = new ThreadGroup(topGroup, "하위 스레드 그룹");
 
+        //하위 스레드 그룹 내부에 최하위 스레드 그룹 생성
+        ThreadGroup buttomGroup = new ThreadGroup(subGroup, "최하위 스레드 그룹");
+
         // 최상위 스레드 그룹에 속한 스레드 생성
         Thread topGroupThread = new Thread(topGroup, new MyRunnable(), "TopGroupThread");
 
         // 하위 스레드 그룹에 속한 스레드 생성
         Thread subGroupThread = new Thread(subGroup, new MyRunnable(), "SubGroupThread");
 
+        //최하위 스레드 그룹에 속한 스레드 생성
+        Thread buttomGroupThread = new Thread(buttomGroup, new MyRunnable(), "ButtomGroupThread");
+
         // 그룹 정보 출력
         System.out.println(topGroupThread.getName() + " 는 " + topGroupThread.getThreadGroup().getName() + "에 속해 있습니다.");
         System.out.println(subGroupThread.getName() + " 는 " + subGroupThread.getThreadGroup().getName() + "에 속해 있습니다.");
+        System.out.println(buttomGroupThread.getName() + " 는 " + buttomGroupThread.getThreadGroup().getName() + "에 속해 있습니다.");
+
 
         topGroupThread.start();
         subGroupThread.start();
+        buttomGroupThread.start();
 
         try {
             Thread.sleep(1000);
diff --git a/src/main/java/io/concurrency/chapter04/exam04/README.md b/src/main/java/io/concurrency/chapter04/exam04/README.md
new file mode 100644
index 0000000..3b3aa81
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter04/exam04/README.md
@@ -0,0 +1,16 @@
+## ThreadGroupScopeExample
+
+- 이미 생성된 스레드의 우선순위를 런타임 중에 변경할 수 없다
+- 중첩된 스레드 그룹을 형성했을 때, 모든 스레드는 부모 스레드 그룹의 최대 우선순위 설정을 갖는다 
+  - 부모 스레드 그룹의 최대 우선순위가 4이고 자식 스레드 그룹의 최대 우선순위가 7이라도, 모든 스레드(자식 스레드 그룹의 스레드도 포함)의 최대 우선순위는 4이다
+
+- Q. 중첩 스레드는 실무에서 어떤 경우에 사용하는가?
+```text
+스레드 안에서 스레드를 사용하는 경우가 흔치는 않지만 서로간 비동기적으로 작업을 처리해야 할 경우 중첩해서 구현하기도 합니다
+
+어떻게 보면 메인스레드 안에서 스레드를 생성하는 것도 중첩스레드라 볼 수 있습니디
+
+한 스레드가 요청을 처리하다가 너무 시간이 오래 걸리는 작업이 있다면 별도의 스레드를 만들어 작업을 위임할 수도 있습니다
+
+상황에 따라 비동기적인 구현이 필요할 때 스레드 안에 또 다른 스레드를 포함할 수 있습니다
+```
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupAPIExample.java b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupAPIExample.java
index 620622b..bdf50fa 100644
--- a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupAPIExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupAPIExample.java
@@ -5,6 +5,7 @@ public static void main(String[] args) throws InterruptedException {
 
         ThreadGroup topGroup = new ThreadGroup("상위그룹");
 
+
         // 상위 스레드 그룹에 속하는 스레드들 생성
         Thread[] topThreads = new Thread[5];
         for (int i = 1; i <= 5; i++) {
diff --git a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupInterruptExample.java b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupInterruptExample.java
index 4ea8211..13a23d4 100644
--- a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupInterruptExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupInterruptExample.java
@@ -12,7 +12,8 @@ public static void main(String[] args) throws InterruptedException {
                 try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
-                    e.printStackTrace();
+                    //e.printStackTrace();
+                    System.err.println(topGroup + "스레드 그룹 중단");
                     return;
                 }
             }
@@ -24,7 +25,8 @@ public static void main(String[] args) throws InterruptedException {
                 try {
                     Thread.sleep(500);
                 } catch (InterruptedException e) {
-                    e.printStackTrace();
+                    //e.printStackTrace();
+                    System.err.println(subGroup + "스레드 그룹 중단");
                     return;
                 }
             }
diff --git a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupScopeExample.java b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupScopeExample.java
index 3f273d0..1f4e222 100644
--- a/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupScopeExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam04/ThreadGroupScopeExample.java
@@ -6,6 +6,7 @@ public static void main(String[] args) throws InterruptedException {
         ThreadGroup topGroup = new ThreadGroup("상위그룹");
         ThreadGroup subGroup = new ThreadGroup(topGroup, "하위그룹");
 
+
         // 상위 그룹 스레드에서 하위 그룹의 최대 우선 순위를 변경
         Thread topGroupThread = new Thread(topGroup, () -> {
             System.out.println("상위 그룹 스레드에서 하위 그룹의 최대 우선 순위 변경 전: " + subGroup.getMaxPriority());
@@ -26,16 +27,20 @@ public static void main(String[] args) throws InterruptedException {
         topGroupThread.join();
         subGroupThread.join();
 
-        // 이미 생성된 스레드는 변경사항이 적용되지 않는다
+        // 이미 생성된 스레드는 변경사항(우선순위 변경)이 적용되지 않는다
         System.out.println(topGroupThread.getName() + ": " + topGroupThread.getPriority());
         System.out.println(subGroupThread.getName() + ": " + subGroupThread.getPriority());
 
+        //스레드 그룹이 중첩되어서, 부모-자식 관계가 형성되었다면, 부모 그룹의 최대 우선순위 설정 사항이 자식 스레드 그룹에도 적용된다
+        //즉 부모의 우선순위가 4이고, 자식의 우선순위가 7이라면, 부모 스레드그룹에 속한 모든 스레드(당연히 자식 스레드 그룹 포함)들은 우선순위 4를 가진다
         Thread userThread1 = new Thread(topGroup, () -> {}, "유저스레드 1");
         Thread userThread2 = new Thread(subGroup, () -> {}, "유저스레드 2");
 
         userThread1.start();
         userThread2.start();
 
+
+
         userThread1.join();
         userThread2.join();
 
diff --git a/src/main/java/io/concurrency/chapter04/exam05/README.md b/src/main/java/io/concurrency/chapter04/exam05/README.md
new file mode 100644
index 0000000..f82244c
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter04/exam05/README.md
@@ -0,0 +1,12 @@
+## ThreadLocalExample
+
+```java
+private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "Hello World");
+```
+- 위처럼 초기값을 세팅한후 threadLocal을 계속 사용하다가 threadLocal.remove()를 하게 되면, 초기값만 남겨두고 다 삭제한다. 따라서 이후 get() 하면 초기값이 튀어나옴
+
+
+## ThreadPoolThreadLocalExample
+- 스레드풀은 많은 요청에 대해서 이미 생성된 스레드를 재사용하기 때문에 tl에 저장된 값을 반드시 remove 해줘야 함
+- 
+
diff --git a/src/main/java/io/concurrency/chapter04/exam05/ThreadLocalExample.java b/src/main/java/io/concurrency/chapter04/exam05/ThreadLocalExample.java
index aa3fdea..81ca368 100644
--- a/src/main/java/io/concurrency/chapter04/exam05/ThreadLocalExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam05/ThreadLocalExample.java
@@ -2,8 +2,9 @@
 
 public class ThreadLocalExample {
     // ThreadLocal 변수 생성. 초기값은 null
-    private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "Hello World");
-//    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
+    //private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "Hello World");
+    private static ThreadLocal<String> threadLocal = new ThreadLocal<>(); //이렇게 하면 아무것도 set하지 않은 상태에서 get() 했을 때 null 나오게 됨
+
 
     public static void main(String[] args) {
 
@@ -12,8 +13,12 @@ public static void main(String[] args) {
             System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
             threadLocal.set("스레드 1의 값");
             System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
+            threadLocal.remove(); //원래 초기값만 남겨두고 삭제함
+            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get()); //초기값 튀어나옴
         }, "Thread-1");
 
+
+
         // 두 번째 스레드: ThreadLocal 값을 설정하고 출력
         Thread thread2 = new Thread(() -> {
             System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
diff --git a/src/main/java/io/concurrency/chapter04/exam05/ThreadPoolThreadLocalExample.java b/src/main/java/io/concurrency/chapter04/exam05/ThreadPoolThreadLocalExample.java
index 7ed7cec..6834cd4 100644
--- a/src/main/java/io/concurrency/chapter04/exam05/ThreadPoolThreadLocalExample.java
+++ b/src/main/java/io/concurrency/chapter04/exam05/ThreadPoolThreadLocalExample.java
@@ -15,7 +15,7 @@ public static void main(String[] args) {
             threadLocal.set("작업 1의 값");
             System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
             // 작업 종료 후 값을 지워야 함
-//            threadLocal.remove();
+            threadLocal.remove();
         });
 
         // 잠시 대기
diff --git a/src/main/java/io/concurrency/chapter05/exam01/README.md b/src/main/java/io/concurrency/chapter05/exam01/README.md
new file mode 100644
index 0000000..b9a299a
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter05/exam01/README.md
@@ -0,0 +1,4 @@
+### MultiThreadExample
+- sum 변수에 스레드1과 스레드2가 동시에 접근하기 때문에 한 스레드가 작업 중일 때 다른 스레드가 접근하지 않는다는 것을 보장해야 한다 -> 동시성
+- 여러 스레드가 lock을 걸지 않은 채 지역 변수에 접근하게 되면 기대하는 결과 값이 나오지 않는다!!
+- CPU 멀티 코어를 활용할 수 있기 때문에 병렬성 측면에서 좋지만 동시성과 동기화를 꼭 주의해야 한다
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter05/exam01/SingleThreadExample.java b/src/main/java/io/concurrency/chapter05/exam01/SingleThreadExample.java
index f836e19..f2a400f 100644
--- a/src/main/java/io/concurrency/chapter05/exam01/SingleThreadExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam01/SingleThreadExample.java
@@ -9,7 +9,7 @@ public static void main(String[] args) {
             sum += i;
             try {
                 Thread.sleep(1);
-                throw new RuntimeException("error");
+                throw new RuntimeException("error"); //싱글 스레드니까 에러 터지면 애플리케이션 종료
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
diff --git a/src/main/java/io/concurrency/chapter05/exam02/CpuNonSyncExample.java b/src/main/java/io/concurrency/chapter05/exam02/CpuNonSyncExample.java
index 09fdfd2..a43fa36 100644
--- a/src/main/java/io/concurrency/chapter05/exam02/CpuNonSyncExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam02/CpuNonSyncExample.java
@@ -25,6 +25,6 @@ public static void main(String[] args) throws InterruptedException {
         thread2.join();
 
         System.out.println("예상 결과: " + (2 * ITERATIONS));
-        System.out.println("실제 결과: " + count);
+        System.out.println("실제 결과: " + count); //CPU가 동기화되지 않은 값을 보게 됨
     }
 }
diff --git a/src/main/java/io/concurrency/chapter05/exam03/CriticalSectionExample.java b/src/main/java/io/concurrency/chapter05/exam03/CriticalSectionExample.java
index d349c4a..4603748 100644
--- a/src/main/java/io/concurrency/chapter05/exam03/CriticalSectionExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam03/CriticalSectionExample.java
@@ -1,7 +1,7 @@
 package io.concurrency.chapter05.exam03;
 
 public class CriticalSectionExample {
-    public static void main(String[] args) {
+    public static void main(String[] args)  {
         SharedResource resource = new SharedResource();
 
         Thread t1 = new Thread(resource::increment);
diff --git a/src/main/java/io/concurrency/chapter05/exam03/README.md b/src/main/java/io/concurrency/chapter05/exam03/README.md
new file mode 100644
index 0000000..08b7c50
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter05/exam03/README.md
@@ -0,0 +1,6 @@
+## 임계 구역과 경쟁 상태
+임계 구역과 경쟁 상태는 뗄 수 없는 관계이다
+
+경재 상태에 들어가려면 임계 구역이 있어야 되는 거고, 임계 구역은 경쟁 상태를 만들게 된다
+따라서 하나의 영역 안에서 두 개의 일들이 발생할 수 있다
+
diff --git a/src/main/java/io/concurrency/chapter05/exam04/ImmutableExample.java b/src/main/java/io/concurrency/chapter05/exam04/ImmutableExample.java
index 8771799..ef9523f 100644
--- a/src/main/java/io/concurrency/chapter05/exam04/ImmutableExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam04/ImmutableExample.java
@@ -16,16 +16,22 @@ public static void main(String[] args) {
 
         ImmutablePerson person = new ImmutablePerson("홍길동", 25);
 
+        //여러 스레드에서 하나의 참조 객체를 공유하게 되면 잘못된 결과가 나올 수 있다
+        //그러나 이 경우는 스레드 안전한데,
+        //그 이유는 공유하고 있는 참조 객체가 final, 즉 불변 객체이기 때문이다
         for (int i = 0; i < 10; i++) {
             new Thread(new ImmutableExample(person)).start();
         }
     }
 }
 
+//상속 못 함
+//모든 필드 또한 final로 선언함으로써 필드가 변경될 수 있는 여지를 원천 차단함
 final class ImmutablePerson {
     private final String name;
     private final int age;
 
+    //생성과 동시에 값이 할당되며, 수정 못함
     public ImmutablePerson(String name, int age) {
         this.name = name;
         this.age = age;
diff --git a/src/main/java/io/concurrency/chapter05/exam04/READMD.md b/src/main/java/io/concurrency/chapter05/exam04/READMD.md
new file mode 100644
index 0000000..dd97a1e
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter05/exam04/READMD.md
@@ -0,0 +1,8 @@
+
+여러 스레드가 같은 변수를 바라보게 되면 스레드에 안전하지 않게 된다
+
+1) 스레드 안정성 시나리오
+- 메서드 내에서 지역 객체 참조 -> 각 스레드의 스택에 독립적으로 생성되기 때문
+- 다른 주소 값을 갖는 멤버 변수를 다루는 경우
+- 같은 주소 값을 갖는 멤버 변수를 다루더라도, 그 멤버 변수에 접근하는 것이 synchronized일 때
+- 같은 주소 값을 갖는 멤버 변수를 다루더라도, 그 멤버 변수가 불변 객체일 때
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalReferenceObjectExample.java b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalReferenceObjectExample.java
index 5f7a1c7..d5b5e3a 100644
--- a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalReferenceObjectExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalReferenceObjectExample.java
@@ -14,10 +14,13 @@ public String toString() {
         }
     }
 
-//    LocalObject localObject = new LocalObject();
+    //LocalObject localObject = new LocalObject();
 
     public void useLocalObject() {
         // 지역 객체 참조. 각 스레드는 이 객체의 독립된 인스턴스를 가짐.
+        // 이 메서드가 호출될 때마다 new로 인해 새로운 레퍼런스 객체가 생성되고,
+        // 그 개별 주소가 각각의 스레드 내의 저장소에 저장되기 떄문
+
         LocalObject localObject = new LocalObject();
 
         for (int i = 0; i < 5; i++) {
diff --git a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalVariableExample.java b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalVariableExample.java
index bc7ef77..3a4c836 100644
--- a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalVariableExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeLocalVariableExample.java
@@ -2,7 +2,7 @@
 
 public class ThreadSafeLocalVariableExample {
 
-//    int localSum = 0;
+   //int localSum = 0;
 public void printNumbers(int plus) {
     // 지역 변수, 매개 변수로 정의된 변수. 각 스레드는 이 변수의 독립된 복사본을 가짐.
     int localSum = 0;
diff --git a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeMemberReferenceObjectExample.java b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeMemberReferenceObjectExample.java
index 211d5f1..10ce2ad 100644
--- a/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeMemberReferenceObjectExample.java
+++ b/src/main/java/io/concurrency/chapter05/exam04/ThreadSafeMemberReferenceObjectExample.java
@@ -2,15 +2,17 @@
 
 public class ThreadSafeMemberReferenceObjectExample {
     public static void main(String[] args) throws InterruptedException {
-        new Thread(new MyRunnable(new Company("Company"))).start(); // 스레드에 안전함, 멤버변수를 공유하지 않음
-        new Thread(new MyRunnable(new Company("Company"))).start(); // 스레드에 안전함, 멤버변수를 공유하지 않음
+        new Thread(new MyRunnable(new Company("User"))).start(); // 스레드에 안전함, 멤버변수를 공유하지 않음
+        new Thread(new MyRunnable(new Company("User"))).start(); // 스레드에 안전함, 멤버변수를 공유하지 않음
 
         Thread.sleep(1000);
         System.out.println("============================================================");
 
+        //객체는 레퍼런스로 생성되기 떄문에, company의 주소값이 동일하게 두 스레드의 매개변수에 들어가서 공유하게 됨
         Company company = new Company("Company"); // 스레드에 안전하지 못함, 멤버변수를 공유함
         new Thread(new MyRunnable(company)).start();
         new Thread(new MyRunnable(company)).start();
+
     }
 }
 
@@ -34,6 +36,7 @@ public Company(String name) {
         this.member = new Member(name);
     }
 
+    //지역 변수가 아니라 멤버 변수를 수정하고 있음
     public synchronized void changeName(String name) {
         String oldName = member.getName();
         member.setName(name);
diff --git a/src/main/java/io/concurrency/chapter06/exam01/Mutex.java b/src/main/java/io/concurrency/chapter06/exam01/Mutex.java
index bde656c..f48fe80 100644
--- a/src/main/java/io/concurrency/chapter06/exam01/Mutex.java
+++ b/src/main/java/io/concurrency/chapter06/exam01/Mutex.java
@@ -1,18 +1,21 @@
 package io.concurrency.chapter06.exam01;
+
+//상호 배제 원리를 구현한 클래스
 public class Mutex {
-    private boolean lock = false;
-    public synchronized void acquired() {
-        while (lock) {
+    private boolean lock= false;
+
+    public synchronized void acquired(){
+        while(lock){
             try {
                 wait();
             } catch (InterruptedException e) {
-                e.printStackTrace();
+                throw new RuntimeException(e);
             }
         }
-        this.lock = true;
+        this.lock = true; //임계 영역 진입
     }
-    public synchronized void release() {
+    public synchronized void release(){
         this.lock = false;
-        this.notify();
+        this.notify(); //대기하고 있는 스레드를 깨움
     }
 }
diff --git a/src/main/java/io/concurrency/chapter06/exam01/README.md b/src/main/java/io/concurrency/chapter06/exam01/README.md
new file mode 100644
index 0000000..a624677
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter06/exam01/README.md
@@ -0,0 +1,22 @@
+
+## MutexExample
+
+1. sharedData::sum를 스레드가 매개변수로 받을 수 있는 이유<br>
+
+```java
+SharedData sharedData = new SharedData(new Mutex()); //Runnable을 구현한 클래스가 아님
+
+Thread th1 = new Thread(sharedData::sum);
+```
+Thread 클래스는 Runnable 인터페이스를 받는 생성자를 제공한다<br>
+Runnable 인터페이스는 하나의 메서드만 있는 함수형 인터페이스로, run() 메서드를 정의한다
+
+```java
+@FunctionalInterface
+public interface Runnable {
+    void run();
+}
+```
+이렇게 함수형 인터페이스로 선언되어 있기 때문에 람다 표현식이나 메서드 참조를 통해 run()을 바로 구현하는 것이 가능하다
+
+따라서 Thread 생성자가 이를 Runnable 인터페이스로 변환하여 내부적으로 처리하기 때문에, 굳이 Runnable을 직접 구현하지 않아도 메서드 참조를 사용해 스레드를 생성할 수 있게 되는 것!!
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter06/exam01/SharedData.java b/src/main/java/io/concurrency/chapter06/exam01/SharedData.java
index c59888b..6e6ecb5 100644
--- a/src/main/java/io/concurrency/chapter06/exam01/SharedData.java
+++ b/src/main/java/io/concurrency/chapter06/exam01/SharedData.java
@@ -13,7 +13,7 @@ public void sum() {
                 sharedValue++;
             }
 
-        } finally {
+        } finally { //for 구문 돌다가 오류날 수 있으므로 반드시 try-finally를 통해 락을 해제해준다
             mutex.release(); // Lock 해제
         }
     }
diff --git a/src/main/java/io/concurrency/chapter06/exam02/BinarySemaphore.java b/src/main/java/io/concurrency/chapter06/exam02/BinarySemaphore.java
index 837572c..be9162f 100644
--- a/src/main/java/io/concurrency/chapter06/exam02/BinarySemaphore.java
+++ b/src/main/java/io/concurrency/chapter06/exam02/BinarySemaphore.java
@@ -15,7 +15,7 @@ public synchronized void acquired() {
     }
 
     public synchronized void release() {
-        this.signal = 1;
-        this.notify();
+        this.signal = 1; //다른 스레드들이 사용 가능함을 설정
+        this.notify(); // 모든 대기 스레드 중 임의로 선택한 스레드 하나만 깨움.
     }
 }
diff --git a/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphore.java b/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphore.java
index becb077..a5bb368 100644
--- a/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphore.java
+++ b/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphore.java
@@ -9,20 +9,34 @@ public CountingSemaphore(int permits) {
         this.signal = permits;
     }
 
-    public void acquired() {
-        synchronized (this) {
-            while (this.signal == 0) {
-                try {
-                    wait();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+
+    public synchronized void acquired(){
+        while(this.signal==0){
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
             }
-            this.signal--;
         }
-        System.out.println(Thread.currentThread().getName() + " 락 획득, 현재 세마포어 값: " + signal);
+        this.signal--;
+        System.out.println(Thread.currentThread().getName() + ": 락 획득, 현재 세마포어 값: "+signal);
     }
 
+//    public void acquired() {
+//        synchronized (this) {
+//            while (this.signal == 0) {
+//                try {
+//                    wait();
+//                } catch (InterruptedException e) {
+//                    e.printStackTrace();
+//                }
+//            }
+//            this.signal--;
+//        }
+//        System.out.println(Thread.currentThread().getName() + " 락 획득, 현재 세마포어 값: " + signal);
+//    }
+
+
     public synchronized void release() {
         if (this.signal < permits) { // signal 값이 permits 보다 작을 때만 증가
             this.signal++;
diff --git a/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphoreExample.java b/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphoreExample.java
index c001a8e..63dabe6 100644
--- a/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphoreExample.java
+++ b/src/main/java/io/concurrency/chapter06/exam02/CountingSemaphoreExample.java
@@ -3,11 +3,11 @@
 public class CountingSemaphoreExample {
     public static void main(String[] args) {
 
-        int permits = 10; // 최대 3개의 스레드가 동시에 작업을 수행할 수 있습니다.
+        int permits = 3; // 최대 3개의 스레드가 동시에 작업을 수행할 수 있습니다.
         CountingSemaphore semaphore = new CountingSemaphore(permits);
         SharedResource resource = new SharedResource(semaphore);
 
-        int threadCount = 5; // 전체 스레드 개수
+        int threadCount = 10; // 전체 스레드 개수
 
         Thread[] threads = new Thread[threadCount];
         for (int i = 0; i < threadCount; i++) {
diff --git a/src/main/java/io/concurrency/chapter06/exam02/REAEMD.md b/src/main/java/io/concurrency/chapter06/exam02/REAEMD.md
new file mode 100644
index 0000000..7ecb888
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter06/exam02/REAEMD.md
@@ -0,0 +1,51 @@
+## Semaphore
+
+- 세마포어: 공유 자원에 대한 접근 제어를 위한 신호 전달 메커니즘 동기화 도구
+  - S: 공유 자원 개수
+    - S > 0 -> 공유 자원 접근 허용
+    - S <= 0 -> 공유 자원 접근 거부
+  - P: 스레드 진입 여부 결정 (wait 연산)
+  - V: 대기 중인 스레드를 깨우는 (signal 연산) <br>
+
+---> 같은 세마포어의 P,V 함수의 S 연산은 원자적 실행이 보장되어야 한다(보장된다)
+
+
+Mutex는 락을 획득하고 해제한 스레드가 동일해야 하지만<br>
+Semaphore는 락을 획득하고 해제한 스레드가 같지 않아도 된다
+
+Mutex는 기본적으로 잠긴 상태로 초기 시작되지만, 세마포어는 초기값 설정을 통해 공유 자원에 몇 개의 동시 스레드를 허용할 것인지 설정할 수 있다
+
+이진 세마포어를 구현한다면 Mutex와 동일하게 구현 가능
+
+Mutex가 상호 배제 목적에 더 부합하고, Semaphore는 주로 리소스의 한정적 사용을 제한하는데 부합하다
+
+
+ex) 이진 세마포어
+
+```java
+public class BinarySemaphore implements CommonSemaphore {
+    private int signal = 1;
+
+    public synchronized void acquired() {
+        while (this.signal == 0) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); // 현재 스레드의 인터럽트 상태를 설정
+            }
+        }
+        this.signal = 0;
+    }
+
+    public synchronized void release() {
+        this.signal = 1; //다른 스레드들이 사용 가능함을 설정
+        this.notify(); // 모든 대기 스레드 중 임의로 선택한 스레드 하나만 깨움.
+    }
+}
+```
+
+synchronized가 붙은 메서드가 호출되면 해당 객체의 다른 synchronized가 붙은 어떤 메서드들도 호출될 수 없다
+따라서 release()의 원자적 실행이 보장되며, 이는 V연산(signal)의 원자적 실행을 보장하는 것이다
+임계 영역을 끝낸 스레드는 acquired()에 의해 wait 중인 대기 스레드들 중 하나를 notify()함으로써 다른 스레드의 진입을 허용한다
+
+
diff --git a/src/main/java/io/concurrency/chapter06/exam05/README.md b/src/main/java/io/concurrency/chapter06/exam05/README.md
new file mode 100644
index 0000000..cfaf0ed
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter06/exam05/README.md
@@ -0,0 +1,28 @@
+## SpinLock
+
+다음 동기화 기법 중에서
+- Mutex
+- Semaphore
+- SpinLock
+
+
+Mutex와 Semaphore는 락에 획득하지 못한 스레드가 대기에 빠지지만 <br>
+SpinLock의 경우 락에 획득하지 못한 스레드는 대기에 빠지지 않고 Busy Waiting을 하게 된다
+
+
+Busy Waiting은 스레드가 락 획득을 위해 반복적으로 바쁘게 락 획득을 시도하는 것을 의미하며, <br>
+이를 위한 무한 루프 동안 CPU 점유가 발생하게 된다<br>
+
+그렇지만 스레드가 블로킹되지 않고 바로 공유 자원에 접근을 시도하기 때문에 <br>
+컨텍스트 스위칭 시간보다 임계 영역의 대기 시간이 더 짧은 경우 
+`컨텍스트 스위칭 비용 감소` & `대기 시간 감소`라는 장점을 갖는다
+
+
+### 싱글 코어 & 멀티 코어
+싱글 코어에서 스핀락을 사용하면 해당 스레드가 무한 루프를 돌면서 다른 스레드가 CPU를 점유할 기회를 주지 않기 때문에
+싱글 코어 환경에서는 일반적으로 busy waiting으로 인해 성능이 저하될 수 있으므로 멀티 코어 환경에서 사용하는 것이 더 효율적이다
+
+
+
+* 스핀락은 멀티 코어 환경에 상관없이 대기 시간이 긴 경우나 공유 자원에 대한 경쟁이 많은 경우에는
+다른 동기화 기법을 고려하는 것이 좋다
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter06/exam05/SpinLockVsSynchronized.java b/src/main/java/io/concurrency/chapter06/exam05/SpinLockVsSynchronized.java
index d33ea43..176fe5b 100644
--- a/src/main/java/io/concurrency/chapter06/exam05/SpinLockVsSynchronized.java
+++ b/src/main/java/io/concurrency/chapter06/exam05/SpinLockVsSynchronized.java
@@ -7,7 +7,7 @@ public class SpinLockVsSynchronized {
     private final Object syncLock = new Object();
     private int count = 0;
 
-    final static int THREAD_COUNT = 5;
+    final static int THREAD_COUNT = 5000; //스레드 숫자를 늘리면 컨텍스트 스위칭 시간이 더 늘어나기 때문에 synchronized보다 spin lock이 더 빠른 경우가 나올 수 있다..
     final int ITERATIONS = 10_000_000;
 
     public void useSpinLock() {
diff --git a/src/main/java/io/concurrency/chapter07/exam01/README.md b/src/main/java/io/concurrency/chapter07/exam01/README.md
new file mode 100644
index 0000000..9c36f8f
--- /dev/null
+++ b/src/main/java/io/concurrency/chapter07/exam01/README.md
@@ -0,0 +1,69 @@
+## synchronized 기본
+
+자바에 내장된 락으로서 암묵적인 락 또는 모니터 락이라 한다
+
+즉 synchronized 안에 모니터가 들어간 것이라 보면 됨
+synchronized를 사용한 동기화 방법 4가지
+- synchronized method
+- static synchronized method
+- synchronized block
+- static synchronized block
+
+
+1. 메서드 동기화 방식 (synchronized method)
+- 메서드 전체가 임계 영역이 되므로 메서드 내 모든 코드가 동기화됨
+- 동시성 문제를 한번에 제어할 수 있지만 메서드 내 코드의 세부적인 동기화 구조를 갖기 어려움
+- 따라서 동기화 영역이 큰 경우 성능 저하 가능
+- 인스턴스 메서드 동기화 방식과 정적 메서드 동기화 방식이 있다
+
+2. 블록 동기화 방식 (synchronized block)
+- 특정 블록을 정해서 임계 영역을 구성 -> 즉 블록 내 코드만 동기화
+- 메서드 동기화 방식에 비해 좀 더 세부적이고 효율적으로 임계 영역 설정 가능
+- 인스턴스 블록 동기화 방식과 정적 블록 동기화 방식이 있다
+
+
+ex)
+```java
+
+public class A {
+    
+    public synchronized void method1(){
+        
+    }
+    
+    public static synchronized method2(){
+        
+    }
+    
+    public void method3(){
+        synchronized (this){
+            
+        }
+    }
+    
+    public static void method4(){
+        synchronized (A.class){
+            
+        }
+    }
+}
+
+```
+class A에 존재하는 모니터는 2개이다<br>
+method1과 method3은 같은 모니터를 M1을 갖고 (개별 인스턴스 레벨의 동기화를 담당)<br>
+method2와 method4는 같은 모니터 M2를 갖는다 (클래스 레벨의 전역적인 동기화를 담당)<br>
+
+따라서 method1에 한 스레드가 접근한다면, 동시에 다른 스레드가 method2에 접근할 수 있다
+
+```java
+A a1 = new A();
+A a2 = new A();
+```
+
+
+스레드 1이 a1.method1()을 실행할 떄, 다른 스레드는 a1.method1() 또는 a1.method3()을 실행할 수 없다<br>
+하지만 a2.method1() 또는 a2.method3()은 실행 가능한 것<br>
+
+스레드 1이 A.method2()를 실행 중일 때<br>
+다른 스레드는 A.method2() 또는 A.method4()를 실행할 수 없고<br>
+이는 a1, a2에 모두 적용된다
\ No newline at end of file
diff --git a/src/main/java/io/concurrency/chapter07/exam01/SynchronizedExamples.java b/src/main/java/io/concurrency/chapter07/exam01/SynchronizedExamples.java
index 1c6e2f5..1afd359 100644
--- a/src/main/java/io/concurrency/chapter07/exam01/SynchronizedExamples.java
+++ b/src/main/java/io/concurrency/chapter07/exam01/SynchronizedExamples.java
@@ -1,33 +1,65 @@
 package io.concurrency.chapter07.exam01;
 
 public class SynchronizedExamples {
+
     private int instanceCount = 0;
     private static int staticCount = 0;
 
-    public synchronized void instanceMethod() {
+    //메서드 동기화 방식 - 인스턴스 메서드 -> 모니터 M1
+    public synchronized void instanceMethod(){
         instanceCount++;
-        System.out.println("인스턴스 메서드 동기화: " + instanceCount);
+        System.out.println("인스턴스 메서드 동기화: "+ instanceCount);
     }
 
-    public static synchronized void staticMethod() {
+    //메서드 동기화 방식 - 클래스 객체 -> 모니터 M2
+    public synchronized static void staticMethod(){
         staticCount++;
-        System.out.println("정적 메서드 동기화: " + staticCount);
+        System.out.println("정적 메서드 동기화: "+staticCount);
     }
 
-    public void instanceBlock() {
-        synchronized (this) {
+    //블록 동기화 방식 - 인스턴스 객체 -> 모니터 M1
+    public void instanceBlock(){
+        synchronized (this){
             instanceCount++;
-            System.out.println("인스턴스 블록 동기화: " + instanceCount);
+            System.out.println("인스턴스 블록 동기화: "+instanceCount);
         }
     }
 
-    public static void staticBlock() {
-        synchronized (SynchronizedExamples.class) {
+    //블록 동기화 방식 - 클래스 객체 -> 모니터 M2
+    public static void staticBlock(){
+        synchronized (SynchronizedExamples.class){
             staticCount++;
-            System.out.println("정적 블록 동기화: " + staticCount);
+            System.out.println("정적 블록 동기화: "+staticCount);
         }
     }
 
+//    private int instanceCount = 0;
+//    private static int staticCount = 0;
+//
+//    public synchronized void instanceMethod() {
+//        instanceCount++;
+//        System.out.println("인스턴스 메서드 동기화: " + instanceCount);
+//    }
+//
+//    public static synchronized void staticMethod() {
+//        staticCount++;
+//        System.out.println("정적 메서드 동기화: " + staticCount);
+//    }
+//
+//    public void instanceBlock() {
+//        synchronized (this) {
+//            instanceCount++;
+//            System.out.println("인스턴스 블록 동기화: " + instanceCount);
+//        }
+//    }
+//
+//    public static void staticBlock() {
+//        synchronized (SynchronizedExamples.class) {
+//            staticCount++;
+//            System.out.println("정적 블록 동기화: " + staticCount);
+//        }
+//    }
+
     public static void main(String[] args) {
         SynchronizedExamples example = new SynchronizedExamples();