diff --git a/AWS/AWS-Service.md b/AWS/AWS-Service.md
index 4d4ebb9..84fbcbb 100644
--- a/AWS/AWS-Service.md
+++ b/AWS/AWS-Service.md
@@ -172,4 +172,4 @@ CloudWatch의 경고 기능은 AWS 상의 각종 리스스에 대한 지표를 
 CloudWatch Logs에는 로그 수집과 모니터링이라는 두 가지 기능이 있습니다. 먼저 로그 수집은 EC2 인스턴스나 Elastic Beanstalk 등의 로그를 S3에 저장합니다. 인스턴스의 경우 전용 에이전트를 설치합니다.
 
 ### CloudWatch Events의 로그 기둥
-CloudWatch Events는 이벤트를 감지하고 지정된 규칙에 따라 처리하는 서비스입니다. 규칙에는 5분 간격이나 특정 일시 등의 스케줄, DnamoDB 테이블의 생성 삭제 등 AWS 리소스에 발생한 변경을 지정하는 것이 가능합니다.
\ No newline at end of file
+CloudWatch Events는 이벤트를 감지하고 지정된 규칙에 따라 처리하는 서비스입니다. 규칙에는 5분 간격이나 특정 일시 등의 스케쥴, DnamoDB 테이블의 생성 삭제 등 AWS 리소스에 발생한 변경을 지정하는 것이 가능합니다.
\ No newline at end of file
diff --git "a/AWS/AWS-\354\204\234\353\271\204\354\212\244-\355\214\250\355\204\264-\354\240\225\353\246\254.md" "b/AWS/AWS-\354\204\234\353\271\204\354\212\244-\355\214\250\355\204\264-\354\240\225\353\246\254.md"
index 8e5466b..bb21def 100644
--- "a/AWS/AWS-\354\204\234\353\271\204\354\212\244-\355\214\250\355\204\264-\354\240\225\353\246\254.md"
+++ "b/AWS/AWS-\354\204\234\353\271\204\354\212\244-\355\214\250\355\204\264-\354\240\225\353\246\254.md"
@@ -11,7 +11,7 @@
     - [Scaling 정책/계획](#scaling-%EC%A0%95%EC%B1%85%EA%B3%84%ED%9A%8D)
       - [수동 스케일](#%EC%88%98%EB%8F%99-%EC%8A%A4%EC%BC%80%EC%9D%BC)
       - [자동 스케일링](#%EC%9E%90%EB%8F%99-%EC%8A%A4%EC%BC%80%EC%9D%BC%EB%A7%81)
-      - [스케줄 기반](#%EC%8A%A4%EC%BC%80%EC%A4%84-%EA%B8%B0%EB%B0%98)
+      - [스케쥴 기반](#%EC%8A%A4%EC%BC%80%EC%A4%84-%EA%B8%B0%EB%B0%98)
       - [규칙 기반](#%EA%B7%9C%EC%B9%99-%EA%B8%B0%EB%B0%98)
 - [인 메모리 캐시 패턴](#%EC%9D%B8-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EC%BA%90%EC%8B%9C-%ED%8C%A8%ED%84%B4)
 - [인프라 구축 자동화](#%EC%9D%B8%ED%94%84%EB%9D%BC-%EA%B5%AC%EC%B6%95-%EC%9E%90%EB%8F%99%ED%99%94)
@@ -78,7 +78,7 @@ Auto Scaling은 서버의 이용 상황에 따라 자동으로 서버의 수를
 #### 자동 스케일링
 최소 대수를 희망 대수 값과 동일하게 설정해 초기의 인스턴스 대수를 유지하는 방식입니다. Auto Scaling 그룹 인스턴스에 뭔가 문제가 발생하고 유요한 인스턴스의 수가 줄었을 때 자동으로 인스턴스가 구축되는, 최소한으로 필요한 인스턴스 대수를 유지하는 방식입니다.
 
-#### 스케줄 기반
+#### 스케쥴 기반
 설저한 시간에 맞춰 서버 대수를 증감시키는 방식 18 시부터 22시 까지 요청이 많은 서비스에 대해서 17:55에 인스턴스를 8대로 한다. 등 같은 피크 시간이 왔다 갔다 하거나 인스턴스를 시작하는데 시간이 걸리는 것을 고려해서 시간을 결정해야 합니다.
 
 #### 규칙 기반
diff --git "a/Database/\352\264\200\352\263\204\355\230\225_\353\215\260\354\235\264\355\204\260\353\262\240\354\235\264\354\212\244_\354\213\244\354\240\204_\354\236\205\353\254\270.md" "b/Database/\352\264\200\352\263\204\355\230\225_\353\215\260\354\235\264\355\204\260\353\262\240\354\235\264\354\212\244_\354\213\244\354\240\204_\354\236\205\353\254\270.md"
index a204192..bfd10bf 100644
--- "a/Database/\352\264\200\352\263\204\355\230\225_\353\215\260\354\235\264\355\204\260\353\262\240\354\235\264\354\212\244_\354\213\244\354\240\204_\354\236\205\353\254\270.md"
+++ "b/Database/\352\264\200\352\263\204\355\230\225_\353\215\260\354\235\264\355\204\260\353\262\240\354\235\264\354\212\244_\354\213\244\354\240\204_\354\236\205\353\254\270.md"
@@ -325,15 +325,15 @@ ACID에 있어 일관성이란 트랜잭션을 실시한 전후에는 데이터
 
 ### 갱신 분실
 
-## 스케줄과 잠금
-앞서 언급한 비정상 상태는 모두 동시성 문제다. 각 처리를 순서대로 수행하면 문제가 발생하지 않는다. 스케줄이라는 관점에서 보면 앞에서 언급한 비정상 상태가 발생하는 스케줄은 원래 실행하면 안되는 것이다. **따라서 스케줄이 발생하지 않도록 트랜잭션의 스케줄을 결정해야 한다.**
+## 스케쥴과 잠금
+앞서 언급한 비정상 상태는 모두 동시성 문제다. 각 처리를 순서대로 수행하면 문제가 발생하지 않는다. 스케쥴이라는 관점에서 보면 앞에서 언급한 비정상 상태가 발생하는 스케쥴은 원래 실행하면 안되는 것이다. **따라서 스케쥴이 발생하지 않도록 트랜잭션의 스케쥴을 결정해야 한다.**
 
 쿼리의 실행에 따라 트랜잭션 내에 데이터의 일관성이 무너지지 않도록 작업 대상이 되는행에 대해 그 작업이 수행되기 전에 잠금을 거는 방법이 사용되고 있다.
 
 ## 교착 상태
 트랜잭션이 필요로 하는 데이터 항목을 순서대로 작ㅁ그는 아키텍처는 교착 상태라는 문제가 있다. RDB는 행 수준의 잠금 혹은 페이지 수준의 잠금으로 구현돼 이으며 이러한 현상이 이 일어난다.
 
-교착 상태가 발생했다는 것은 만약에 잠금을 하지 않고 그대로 처리했다면 데이터의 부정합이 일어난다는 의미다.이런 스케줄은 허용할 수 없으므로 교착 상태에 빠진 트랜잭션은 롤백 해야한다.
+교착 상태가 발생했다는 것은 만약에 잠금을 하지 않고 그대로 처리했다면 데이터의 부정합이 일어난다는 의미다.이런 스케쥴은 허용할 수 없으므로 교착 상태에 빠진 트랜잭션은 롤백 해야한다.
 
 ## 트랜잭션 격리 수준
 
@@ -344,7 +344,7 @@ ACID에 있어 일관성이란 트랜잭션을 실시한 전후에는 데이터
 | REPEATABLE-READ   | X        | X         | O         | O        |
 | SERIALIZABLE      | X        | X         | X         | X        |
 
-SERIALIZABLE가 가장 격리성이 높고 트랜잭션을 실행한 결과가 직렬화된 스케줄과 같은 결과를 보장한다. 하지만 격리 수준이 높을 수록 성능에 대해서 낮은 경향이 있기 때문에 신중하게 선택해야한다.
+SERIALIZABLE가 가장 격리성이 높고 트랜잭션을 실행한 결과가 직렬화된 스케쥴과 같은 결과를 보장한다. 하지만 격리 수준이 높을 수록 성능에 대해서 낮은 경향이 있기 때문에 신중하게 선택해야한다.
 
 ## 제약을 활용
 
diff --git a/JAVA/thread.md b/JAVA/thread.md
index dd5fd78..8f7f76f 100644
--- a/JAVA/thread.md
+++ b/JAVA/thread.md
@@ -8,7 +8,7 @@
   - [멀티 스레드, 싱글 스레드](#%EB%A9%80%ED%8B%B0-%EC%8A%A4%EB%A0%88%EB%93%9C-%EC%8B%B1%EA%B8%80-%EC%8A%A4%EB%A0%88%EB%93%9C)
 - [스레드 우선 순위](#%EC%8A%A4%EB%A0%88%EB%93%9C-%EC%9A%B0%EC%84%A0-%EC%88%9C%EC%9C%84)
   - [동시성과 병렬성](#%EB%8F%99%EC%8B%9C%EC%84%B1%EA%B3%BC-%EB%B3%91%EB%A0%AC%EC%84%B1)
-  - [스레드 스케줄링](#%EC%8A%A4%EB%A0%88%EB%93%9C-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81)
+  - [스레드 스케쥴링](#%EC%8A%A4%EB%A0%88%EB%93%9C-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81)
     - [우선 순위](#%EC%9A%B0%EC%84%A0-%EC%88%9C%EC%9C%84)
 - [동기화 메서드와 동기화 블록](#%EB%8F%99%EA%B8%B0%ED%99%94-%EB%A9%94%EC%84%9C%EB%93%9C%EC%99%80-%EB%8F%99%EA%B8%B0%ED%99%94-%EB%B8%94%EB%A1%9D)
   - [공유 객체를 사용할 때 중의 할 점](#%EA%B3%B5%EC%9C%A0-%EA%B0%9D%EC%B2%B4%EB%A5%BC-%EC%82%AC%EC%9A%A9%ED%95%A0-%EB%95%8C-%EC%A4%91%EC%9D%98-%ED%95%A0-%EC%A0%90)
@@ -61,7 +61,7 @@
 * 병렬성(Parallelism)
   * 멀티 작업을 위해 멀티 코어에서 개별 스레드를 동시에 실행하는 성질
 
-## 스레드 스케줄링
+## 스레드 스케쥴링
 
 ![](/draw/thead-shduler.png)
 
diff --git "a/JAVA/\353\236\214\353\213\244\354\213\235-\352\270\260\354\264\210.md" "b/JAVA/\353\236\214\353\213\244\354\213\235-\352\270\260\354\264\210.md"
index eee72e1..80566dd 100644
--- "a/JAVA/\353\236\214\353\213\244\354\213\235-\352\270\260\354\264\210.md"
+++ "b/JAVA/\353\236\214\353\213\244\354\213\235-\352\270\260\354\264\210.md"
@@ -323,7 +323,7 @@ List<Member> members = list.stream()
     * HashSet, TreeSet은 요서를 분리하기가 쉽지 않고, LinkedList는 랜덤 엑세스를 지원하지 않아 링크를 따라가야 하므로 역시 요소를 분리하기가 쉽지않다. 따라서 이들 소스들은 ArrayList 배열 보다는 상대적으로 병럴 처리가 늦다.
   * 코어의수
     * 싱글코어 CPU일 경우에는 순차 처리가 빠르다.
-    * 병렬 처리를 할 경우 스레드 수만 증가하고 번갈아 가면서 스케줄링을 해야하므로 좋지 못한 결과를 준다.
+    * 병렬 처리를 할 경우 스레드 수만 증가하고 번갈아 가면서 스케쥴링을 해야하므로 좋지 못한 결과를 준다.
     * 코어의 수가 많으면 많을 수록 병렬 작업 처리는 속도는 빨라진다.
 
 # 출처
diff --git a/OS/basic.md b/OS/basic.md
index 7b27a44..cd95a1f 100644
--- a/OS/basic.md
+++ b/OS/basic.md
@@ -10,13 +10,13 @@
 - [멀티 프로그래밍](#%EB%A9%80%ED%8B%B0-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D)
   - [멀티 프로그래밍](#%EB%A9%80%ED%8B%B0-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-1)
   - [정리](#%EC%A0%95%EB%A6%AC)
-- [스케줄러 알고리즘](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
+- [스케쥴러 알고리즘](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
   - [프로세스란 ?](#%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EB%9E%80)
-  - [스케줄러와 프로세스](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC%EC%99%80-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4)
+  - [스케쥴러와 프로세스](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC%EC%99%80-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4)
   - [스케쥴링 알고리즘](#%EC%8A%A4%EC%BC%80%EC%A5%B4%EB%A7%81-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
-  - [최단 작업 우선(SJF) 스케줄러](#%EC%B5%9C%EB%8B%A8-%EC%9E%91%EC%97%85-%EC%9A%B0%EC%84%A0sjf-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
+  - [최단 작업 우선(SJF) 스케쥴러](#%EC%B5%9C%EB%8B%A8-%EC%9E%91%EC%97%85-%EC%9A%B0%EC%84%A0sjf-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
   - [우선순위 기반 스케쥴러](#%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84-%EA%B8%B0%EB%B0%98-%EC%8A%A4%EC%BC%80%EC%A5%B4%EB%9F%AC)
-  - [Round Robin 스케줄러](#round-robin-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
+  - [Round Robin 스케쥴러](#round-robin-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
   - [정리](#%EC%A0%95%EB%A6%AC-1)
 - [프로세스 상태](#%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-%EC%83%81%ED%83%9C)
   - [프로세스 상태간 관계](#%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-%EC%83%81%ED%83%9C%EA%B0%84-%EA%B4%80%EA%B3%84)
@@ -139,7 +139,7 @@
 * 멀티 프로그래밍 : 최대한 CPU를 일정 시간당 많이 활용하는 시스템
 
 
-# 스케줄러 알고리즘
+# 스케쥴러 알고리즘
 ## 프로세스란 ?
 
 ![](https://gmlwjd9405.github.io/images/os-process-and-thread/process.png)
@@ -153,33 +153,33 @@
 * 각 프로세스는 별도의 주소 공간에 실행되며, 한 프로세스는 다른 프로세스의 변수나 자료구조에 접근할 수 없다.
 * 프로세스 간의 자원을 공유를 하기 위해서는 IPC(InterProcess Communication) 기법을 이용해야한다.
 
-## 스케줄러와 프로세스
-* 프로세스 실행을 관리하는 것이 스케줄러
+## 스케쥴러와 프로세스
+* 프로세스 실행을 관리하는 것이 스케쥴러
 
 ## 스케쥴링 알고리즘
 * 목표
     * 시분할 시스템 예: 프로세스 응답 시간을 가능한 짧게
     * 멀티 프로그래밍 예: CPU 활용도를 최대로 높혀서, 프로세스를 빨리 실행
 
-## 최단 작업 우선(SJF) 스케줄러
-* SJF 스케줄러 
+## 최단 작업 우선(SJF) 스케쥴러
+* SJF 스케쥴러
     * 가장 프로세스 실행 시간이 짧은 프로세스 부터 먼저 실행 시키는 알고리즘
 
 ## 우선순위 기반 스케쥴러
-* priority-based 스케줄러
+* priority-based 스케쥴러
     * 정적 우선순위
     * 프로세스마다 우선순위를 미리 지정
-    * 동적 우선순위 : 스케줄러가 상황에 따라 우선순위를 동적으로 변경 
+    * 동적 우선순위 : 스케쥴러가 상황에 따라 우선순위를 동적으로 변경
 
-## Round Robin 스케줄러
+## Round Robin 스케쥴러
 * 큐에 쌓아 놓고 일정 시간이 지나면 다시 대기 큐로 돌려 보낸다. 그 뒤에 있는 작업을 진행한다.
 
 ## 정리
-* FIFO 스케줄링 알고리즘 : 배치 시스템
-* 최단 작업 우선 스케줄링 알고리즘
-* 우선순위 기반 스케줄링 알고리즘
+* FIFO 스케쥴링 알고리즘 : 배치 시스템
+* 최단 작업 우선 스케쥴링 알고리즘
+* 우선순위 기반 스케쥴링 알고리즘
     * 정적 순위, 동적 우선 순위
-* Round Robin 스케줄링 알고리즘
+* Round Robin 스케쥴링 알고리즘
     * 시분할 시스템 기반
 
   
@@ -249,7 +249,7 @@
     * 프로세스 정보 상티 
         * PC, SP : 컨텍스트 스위칭
         * 메모리
-        * 스케줄링
+        * 스케쥴링
 
 
 ## 컨텍스트 스위칭 개념 정리
@@ -365,7 +365,7 @@
 * 스레드 중 한 스레드만 문제가 있어도, 전체 프로세스가 영향을 받음
 * 스레드를 많이 생성하면, Context Switching이 많이 일어나, 성능 저하
   * 리눅스에서는 Thread를 Process와 같이 다룸
-  * 스레드를 많이 생성하면, 모든 스레드를 스케줄링해야 하므로, Context Switching이 빈번하게 발생할 수 있다.
+  * 스레드를 많이 생성하면, 모든 스레드를 스케쥴링해야 하므로, Context Switching이 빈번하게 발생할 수 있다.
 
 ### Thread vs Process
 * 프로세스는 독립적, 스레드는 프로세스의 서브넷
diff --git "a/OS/\354\232\264\354\230\201\354\262\264\354\240\234\354\231\200\354\240\225\353\263\264\352\270\260\354\212\254\354\235\230\354\233\220\353\246\254.md" "b/OS/\354\232\264\354\230\201\354\262\264\354\240\234\354\231\200\354\240\225\353\263\264\352\270\260\354\212\254\354\235\230\354\233\220\353\246\254.md"
index b9ea71d..08be462 100644
--- "a/OS/\354\232\264\354\230\201\354\262\264\354\240\234\354\231\200\354\240\225\353\263\264\352\270\260\354\212\254\354\235\230\354\233\220\353\246\254.md"
+++ "b/OS/\354\232\264\354\230\201\354\262\264\354\240\234\354\231\200\354\240\225\353\263\264\352\270\260\354\212\254\354\235\230\354\233\220\353\246\254.md"
@@ -33,12 +33,12 @@
 - [6장 프로세스 관리](#6%EC%9E%A5-%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4-%EA%B4%80%EB%A6%AC)
   - [CPU 버스트](#cpu-%EB%B2%84%EC%8A%A4%ED%8A%B8)
   - [I/O 버스트](#io-%EB%B2%84%EC%8A%A4%ED%8A%B8)
-  - [CPU 스케줄러](#cpu-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
+  - [CPU 스케쥴러](#cpu-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%9F%AC)
     - [비성점형 방식](#%EB%B9%84%EC%84%B1%EC%A0%90%ED%98%95-%EB%B0%A9%EC%8B%9D)
     - [선점형 방식](#%EC%84%A0%EC%A0%90%ED%98%95-%EB%B0%A9%EC%8B%9D)
   - [디스패치](#%EB%94%94%EC%8A%A4%ED%8C%A8%EC%B9%98)
-  - [스케줄링의 성능 평가](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%EC%9D%98-%EC%84%B1%EB%8A%A5-%ED%8F%89%EA%B0%80)
-  - [스케줄링 알고리즘](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
+  - [스케쥴링의 성능 평가](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%EC%9D%98-%EC%84%B1%EB%8A%A5-%ED%8F%89%EA%B0%80)
+  - [스케쥴링 알고리즘](#%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
     - [FCFS](#fcfs)
     - [SJF](#sjf)
 - [7장 메모리 관리](#7%EC%9E%A5-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B4%80%EB%A6%AC)
@@ -163,7 +163,7 @@ CPU는 명령 하나를 수행할 때마다 인터럽트가 발생했는지를 
 2. 프로세스 시작 상태 : 프로세스가 시작되어 그 프로세스를 위한 각종 자료구조는 생성되었지만 아직 메모리 승인받지 못한 생태
 3. 프로세스 시작 상태 : CPU를 할당 받고 기계어 명령을 하나씩 수행해 나가는 상태
 4. 디스크에서 파일을 읽어와야 하는 명령 수행
-5. 디스크 입출력이 진행되는 동안에 이 프로세스가 CPU를 점유하고 있어도 후속 명령을 처리하지 못해서 CPU가 비효율적으로 낭비된다. 따라서 입출력이 완료될 때까지 CPU를 반환한 다음 디스크 입출력 서비스를 기다리는 장치에 큐에 가서 줄을 서게 된다. 이 때 프로세스의 상태는 봉쇄 상태가 된다. 그러면 CPU를 기다리는 준비 큐에 줄 서 있는 프로레스들 중에서 CPU 스케줄러가 적절한 프로세스를 하나 선정해서 CPU를 할당하게 된다.
+5. 디스크 입출력이 진행되는 동안에 이 프로세스가 CPU를 점유하고 있어도 후속 명령을 처리하지 못해서 CPU가 비효율적으로 낭비된다. 따라서 입출력이 완료될 때까지 CPU를 반환한 다음 디스크 입출력 서비스를 기다리는 장치에 큐에 가서 줄을 서게 된다. 이 때 프로세스의 상태는 봉쇄 상태가 된다. 그러면 CPU를 기다리는 준비 큐에 줄 서 있는 프로레스들 중에서 CPU 스케쥴러가 적절한 프로세스를 하나 선정해서 CPU를 할당하게 된다.
 6. CPU를 기다리는 준비 큐에는 입출력 등 오래 기달려야 하는 업무가 진행 중인 프로세스는 줄 서 있지 못하고 CPU만 획득하면 곧바로 명령을 수행할 수 있는 프로레스들만 줄 서 있게 된다.  이러한 상태를 준비 상태라고 한다. 
 7. 디스크 입출력을 요청한 프로세스는 디스크 입출력을 기다리는 장치 큐에 줄서 있다가 자기 차례가 되어 디스크 컨트롤로 부터 서비스를 받고 나면 디스크 컨트롤러가 CPU에게 인터럽트를 발생시켜 입출력이 완료되었다는 것을 알리게 된다.
 8. CPU는 어떤 프로세스를 실행하고 있다가 인터럽트가 발생한 것을 확인하고 그에 대응하는 루틴을 수행하게된다. 이 루틴이 진행되는 동안 CPU에서 수행되던 프로세스를 장치 큐에서 빼내어 CPU를 기다리는 준비 큐에 넣어 주고 프로세스의 상태를 준비 상태로 바꾼 후 장치의 로컬 버퍼에 있는 내용을 메로리에 디동시키는 일련의 업무이다.
@@ -176,8 +176,8 @@ CPU는 명령 하나를 수행할 때마다 인터럽트가 발생했는지를 
 * 프로세스 상태 : 프로세스의 상태는 CPU를 할당해도 되는 지 여부를 결정하기 위해 필요
 * 프로그램 카운터 값 : 다음에 수행할 명령의 위치를 가리킴
 * CPU 레지스터 : CPU 연산을 위해 현 시점에 레지스터에 어떤 값을 저장하고 있는지를 나타냄
-* CPU 스케줄링 정보 : 각각 그 프로세스의 CPU 스케줄링을 위해 필요한 정보
-* 메모리 관리 정보 : 각각 그 프로세스의 CPU 스케줄링을 위해 필요한 정보
+* CPU 스케쥴링 정보 : 각각 그 프로세스의 CPU 스케쥴링을 위해 필요한 정보
+* 메모리 관리 정보 : 각각 그 프로세스의 CPU 스케쥴링을 위해 필요한 정보
 * 자원 사용 정보 : 사용자에게 자원 사용 요금을 계산해 청구하는 등의 용도로 사용 
 * 입출력 상태 정보 
 
@@ -196,9 +196,9 @@ CPU는 명령 하나를 수행할 때마다 인터럽트가 발생했는지를 
 * I/O 요청이 발생해 커널에 의해 입출력 작업을 진행하는 비교적 느린단계
 * I/O 버스트는 I/O 작업이 요청된 후 완료되어 다시 CPU 버스트로 돌아가기까지 일어나는 일련의 작업을 말한다.
 
-## CPU 스케줄러
-* CPU 스케줄러는 준비 상태에 있는 프로세스들 중에 어떠한 프로세스에게 CPU를 할당할지를 결정하는 운영체제의 코드이다.
-* 어떠한 프로세스가 CPU를 할당받고 기계어 명령을 수행하다가 타이머 인터럽트가 발생하면 CPU 스케줄러가 호출된다. 그러면 CPU 스케줄러는 준비 큐에서 CPU를 기다리는 프로세스 중에서 하나를 선택해 CPU를 할당하게된다.
+## CPU 스케쥴러
+* CPU 스케쥴러는 준비 상태에 있는 프로세스들 중에 어떠한 프로세스에게 CPU를 할당할지를 결정하는 운영체제의 코드이다.
+* 어떠한 프로세스가 CPU를 할당받고 기계어 명령을 수행하다가 타이머 인터럽트가 발생하면 CPU 스케쥴러가 호출된다. 그러면 CPU 스케쥴러는 준비 큐에서 CPU를 기다리는 프로세스 중에서 하나를 선택해 CPU를 할당하게된다.
 
 ### 비성점형 방식
 * CPU를 획득한 프로세스가 스스로 CPU를 반납하기 전까지 CPU를 빼앗기지 않는 방법을 말한다.
@@ -207,33 +207,33 @@ CPU는 명령 하나를 수행할 때마다 인터럽트가 발생했는지를 
 
 
 ### 선점형 방식
-* 프로세스가 CPU를 계속 사용하기를 원하더라도 강제로 빼앗을 수 있는 스케줄링 방법을 말한다. 
+* 프로세스가 CPU를 계속 사용하기를 원하더라도 강제로 빼앗을 수 있는 스케쥴링 방법을 말한다.
 * 실행 상테에 있던 프로레스가 타이머 인터럽트 발생에 의해 준비 상태로 바뀌는 경우
 * I/O 요청으로 봉쇄 상태에 있던 프로세스의 I/O 작업이 완료되어 인터럽트가 발생하고 그 결과 이 프로세스의 상태가 준비 상태로 바뀌는 경우
 
 ## 디스패치 
-* CPU 스케줄러가 어떤 프로세스에게 CPU를 할당해야 할지를 결정하고 나면 선택된 프로세스에게 실제로 CPU를 이양하는 작업이 필요하다. **이와 같이 새롭게 선택된 프로세스가 CPU를 할당받고 작업을 수행할 수 있도록 환경을 설정하는 모듈을 디스패처라고 부른다.**
+* CPU 스케쥴러가 어떤 프로세스에게 CPU를 할당해야 할지를 결정하고 나면 선택된 프로세스에게 실제로 CPU를 이양하는 작업이 필요하다. **이와 같이 새롭게 선택된 프로세스가 CPU를 할당받고 작업을 수행할 수 있도록 환경을 설정하는 모듈을 디스패처라고 부른다.**
 * 디스패처는 현재 수행주이던 프로세스의 문맥을 그 프로세스의 PGB에 저장하고, 새롭게 선택된 프로세스의 문맥을 PGB로부터 복원한 후 그 프로세스에게 넘기는 과정을 수행한다.
 * 디스패처 지연시간 : 디스패처가 하나의 프로세스를 정지 시키고 다른 프로세스에게 CPU를 전달하기 까지 걸리는 시간
 
-## 스케줄링의 성능 평가
+## 스케쥴링의 성능 평가
 * CPU 활용도 : 전체 시간 중 CPU가 명령을 수행한 시간의 비율
 * 처리량: 주어진 시간 동안 CPU 버스트를 완료한 프로세스의 개수
 * 소요 시간 : 프로세스가 CPU 요청 시점으로 부터 CPU 버스트가 끝날 때까지 걸린 시간
 * 대기 시간 : 프로세스가 CPU 버스트 기간 중 준비큐에서 기달린 시간의 합
 * 응답 시간 : 프로세스가 CPU 요청 시점으로 처음으로 CPU를 얻을 때까지 기달린 시간
 
-## 스케줄링 알고리즘
+## 스케쥴링 알고리즘
 
 ### FCFS
 * 프로세스가 준비 큐에 도착한 시간 순서대로 CPU를 할당하는 방식을 말한다.
 * CPU를 먼저 요청한 프로세스에게 CPU를 먼저할당하고, 그 프로세스가 자발적으로 CPU를 반납할 때까지 CPU를 선점하지 않는다.
-* 은행, 공항, 화장실 등 일상 생활에서도 흔히 볼수 있듯이 먼저 요청을 먼저 처리하기 때문에 합리적인 스케줄링 방식인 것처럼 느껴지지만 I/O 오래 걸리는 작업이나, CPU 버스트가 짧은 프로세스 등 다양한 이유 때문에 평균 대기시간이 길어지게 된다.
+* 은행, 공항, 화장실 등 일상 생활에서도 흔히 볼수 있듯이 먼저 요청을 먼저 처리하기 때문에 합리적인 스케쥴링 방식인 것처럼 느껴지지만 I/O 오래 걸리는 작업이나, CPU 버스트가 짧은 프로세스 등 다양한 이유 때문에 평균 대기시간이 길어지게 된다.
 
 ### SJF
 * CPU 버스트가 가장 짧은 프로세스 에게 제일 먼저 CPU를 할당하는 방식이다.
 * CPU 버스트가 짧은 프로세스가 CPU를 먼저 사용하는 준비 큐를 빠져나가게 되며 프로세스들이 준비 큐에서 기다리는 전체적인 시간이 줄어들게 된다.
-* SJF 스케줄링 알고리즘은 평균 대기시간이 가장 짧게 하는 최적의 알고리즘으로 알려져있다.
+* SJF 스케쥴링 알고리즘은 평균 대기시간이 가장 짧게 하는 최적의 알고리즘으로 알려져있다.
 
 
 
diff --git a/Spring/batch/batch-basic.md b/Spring/batch/batch-basic.md
index af979e0..7865230 100644
--- a/Spring/batch/batch-basic.md
+++ b/Spring/batch/batch-basic.md
@@ -56,7 +56,7 @@
 * 데이터를 직접 사용하는 편이 빈번하게 일어나므로 데이터 무결성을 우지하는데 유효성 검사 등의 방어책이 있어야합니다.
 * 배치 처리 시스템 I/O 사용을 최소화해야합니다. 잦은 I/O로 데이터베이스 컨넥션과 네트워크 비용이 커지면 성능에 영향을 줄 수 있기 때문입니다. 따라서 가능하면 한번에 데이터를 조회하여 메모리에 저장해두고 처리를 한 다음. 그결과를 한번에 데이터베이스에 저장하는것이 좋습니다.
 * 일반적으로 같은 서비스에 사용되는 웹 API, 배치, 기타 프로젝트들을 서로 영향을 줍니다. 따라서 배치 처리가 진행되는 동안 다른 프로젝트 요소에 영향을 주는 경우가 없는지 주의를 기울여야합니다.
-* 스프링 부트는 배치 스케줄러를 제공하지 않습니다. 따라서 배치 처리 기능만 제공하여 스케줄링 기능은 스프링에서 제공하는 쿼치 프레임워크 등을 이용해야합니다. **리눅스 crontab 명령은 가장 간단히 사용 할 수 있지만 이는 추천하지 않습니다.** crontab의 경우 각 서버마다 따로 스케줄리을 관리해야 하며 무엇보다 클러스터링 기능이 제공되지 않습니다. 반면에 쿼티 같은 스케줄링은 프레임워크를 사용한다면 클러스터링뿐만 아니라 다양한 스케줄링 기능, 실행 이력 관리 등 여러 이점을 얻을 수 있습니다.
+* 스프링 부트는 배치 스케쥴러를 제공하지 않습니다. 따라서 배치 처리 기능만 제공하여 스케쥴링 기능은 스프링에서 제공하는 쿼치 프레임워크 등을 이용해야합니다. **리눅스 crontab 명령은 가장 간단히 사용 할 수 있지만 이는 추천하지 않습니다.** crontab의 경우 각 서버마다 따로 스케쥴리을 관리해야 하며 무엇보다 클러스터링 기능이 제공되지 않습니다. 반면에 쿼티 같은 스케쥴링은 프레임워크를 사용한다면 클러스터링뿐만 아니라 다양한 스케쥴링 기능, 실행 이력 관리 등 여러 이점을 얻을 수 있습니다.
 
 ## 스프링 부트 배치 이해하기
 배치의 일반적인 시나리오는 다음과 같은 3단계로 이루어집니다.
diff --git a/Spring/security/ACL.md b/Spring/security/ACL.md
index 1e858d3..38a40e5 100644
--- a/Spring/security/ACL.md
+++ b/Spring/security/ACL.md
@@ -159,7 +159,7 @@ public class TodoAclConfig {
 * `JdbcMutableAclService`에는 ACL 데이터를 RDBMS에서 관리할 때 필요한 표준 SQL문이 들어 있지만 모든 DB제품이 호환되는건 아닙니다.(아파티 더비)
 
 ### 도메인 객체에 대한 ACL 관리하기
-백엔드 서비스와 DAO에는 의존성 주입을 이용해서 앞서 정의한 ACL 서비스를 이용하여도 도메인 객체용 ACL을 관리해야합니다. 가령 스케줄 관리 앱에서는 할 일을 등록/삭제할 때마다 각각 ACL/생성 삭제해야합니다.
+백엔드 서비스와 DAO에는 의존성 주입을 이용해서 앞서 정의한 ACL 서비스를 이용하여도 도메인 객체용 ACL을 관리해야합니다. 가령 스케쥴 관리 앱에서는 할 일을 등록/삭제할 때마다 각각 ACL/생성 삭제해야합니다.
 
 ```java
 @Service
diff --git "a/\353\217\204\354\204\234/\354\212\244\355\224\204\353\247\2015\353\240\210\354\213\234\355\224\274.md" "b/\353\217\204\354\204\234/\354\212\244\355\224\204\353\247\2015\353\240\210\354\213\234\355\224\274.md"
index d7ffb98..9620861 100644
--- "a/\353\217\204\354\204\234/\354\212\244\355\224\204\353\247\2015\353\240\210\354\213\234\355\224\274.md"
+++ "b/\353\217\204\354\204\234/\354\212\244\355\224\204\353\247\2015\353\240\210\354\213\234\355\224\274.md"
@@ -103,13 +103,13 @@
         - [JavaMail API로 이메일 보내기](#javamail-api%EB%A1%9C-%EC%9D%B4%EB%A9%94%EC%9D%BC-%EB%B3%B4%EB%82%B4%EA%B8%B0)
         - [스프링 MailSender로 이메일 보내기](#%EC%8A%A4%ED%94%84%EB%A7%81-mailsender%EB%A1%9C-%EC%9D%B4%EB%A9%94%EC%9D%BC-%EB%B3%B4%EB%82%B4%EA%B8%B0)
         - [이메일 템플릿 정의하기](#%EC%9D%B4%EB%A9%94%EC%9D%BC-%ED%85%9C%ED%94%8C%EB%A6%BF-%EC%A0%95%EC%9D%98%ED%95%98%EA%B8%B0)
-- [[레시피 13-5] 스프링 쿼츠로 작업 스케줄링하기](#%EB%A0%88%EC%8B%9C%ED%94%BC-13-5-%EC%8A%A4%ED%94%84%EB%A7%81-%EC%BF%BC%EC%B8%A0%EB%A1%9C-%EC%9E%91%EC%97%85-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%ED%95%98%EA%B8%B0)
+- [[레시피 13-5] 스프링 쿼츠로 작업 스케쥴링하기](#%EB%A0%88%EC%8B%9C%ED%94%BC-13-5-%EC%8A%A4%ED%94%84%EB%A7%81-%EC%BF%BC%EC%B8%A0%EB%A1%9C-%EC%9E%91%EC%97%85-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%ED%95%98%EA%B8%B0)
     - [과제](#%EA%B3%BC%EC%A0%9C-16)
     - [해결책](#%ED%95%B4%EA%B2%B0%EC%B1%85-16)
     - [풀이](#%ED%92%80%EC%9D%B4-15)
         - [스프링 없이 쿼츠 직접 사용하기](#%EC%8A%A4%ED%94%84%EB%A7%81-%EC%97%86%EC%9D%B4-%EC%BF%BC%EC%B8%A0-%EC%A7%81%EC%A0%91-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0)
         - [스프링 이용해 쿼츠 사용하기](#%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9D%B4%EC%9A%A9%ED%95%B4-%EC%BF%BC%EC%B8%A0-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0)
-- [[레시피 13-6] 스프링에서 작업 스케줄링하기](#%EB%A0%88%EC%8B%9C%ED%94%BC-13-6-%EC%8A%A4%ED%94%84%EB%A7%81%EC%97%90%EC%84%9C-%EC%9E%91%EC%97%85-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%ED%95%98%EA%B8%B0)
+- [[레시피 13-6] 스프링에서 작업 스케쥴링하기](#%EB%A0%88%EC%8B%9C%ED%94%BC-13-6-%EC%8A%A4%ED%94%84%EB%A7%81%EC%97%90%EC%84%9C-%EC%9E%91%EC%97%85-%EC%8A%A4%EC%BC%80%EC%A4%84%EB%A7%81%ED%95%98%EA%B8%B0)
     - [괘제](#%EA%B4%98%EC%A0%9C)
     - [해결책](#%ED%95%B4%EA%B2%B0%EC%B1%85-17)
     - [풀이](#%ED%92%80%EC%9D%B4-16)
@@ -1607,7 +1607,7 @@ public class TodoAclConfig {
 * `JdbcMutableAclService`에는 ACL 데이터를 RDBMS에서 관리할 때 필요한 표준 SQL문이 들어 있지만 모든 DB제품이 호환되는건 아닙니다.(아파티 더비)
 
 ### 도메인 객체에 대한 ACL 관리하기
-백엔드 서비스와 DAO에는 의존성 주입을 이용해서 앞서 정의한 ACL 서비스를 이용하여도 도메인 객체용 ACL을 관리해야합니다. 가령 스케줄 관리 앱에서는 할 일을 등록/삭제할 때마다 각각 ACL/생성 삭제해야합니다.
+백엔드 서비스와 DAO에는 의존성 주입을 이용해서 앞서 정의한 ACL 서비스를 이용하여도 도메인 객체용 ACL을 관리해야합니다. 가령 스케쥴 관리 앱에서는 할 일을 등록/삭제할 때마다 각각 ACL/생성 삭제해야합니다.
 
 ```java
 @Service
@@ -2289,13 +2289,13 @@ public class EmailErrorNotifier implements ErrorNotifier {
 }
 ```
 
-# [레시피 13-5] 스프링 쿼츠로 작업 스케줄링하기
+# [레시피 13-5] 스프링 쿼츠로 작업 스케쥴링하기
 
 ## 과제
-* 쿼츠 스케줄러를 이용해서 잡 스케줄링을 구성 하세요
+* 쿼츠 스케쥴러를 이용해서 잡 스케쥴링을 구성 하세요
 
 ## 해결책
-* 스프링 제공하는 쿼치 유틸리티 클래스를 이요하면 쿼치 API를 직접 프로그래밍하지 않고 잡을 스케줄링할 수 있습니다.
+* 스프링 제공하는 쿼치 유틸리티 클래스를 이요하면 쿼치 API를 직접 프로그래밍하지 않고 잡을 스케쥴링할 수 있습니다.
 
 ## 풀이
 스프링 유틸리티 클래스 없이 쿼츠를 사용하는 기본적인 방법을 먼저 살펴 보고 쿼치를 사용하는 방법을 소개
@@ -2320,7 +2320,7 @@ public class FileReplicationJob implements Job {
 }
 ```
 ```java
-// 60초마다 한번씩 처음 한번은 5초 있다가 파일을  복제 잡을 생항하는 스케줄러입니다.
+// 60초마다 한번씩 처음 한번은 5초 있다가 파일을  복제 잡을 생항하는 스케쥴러입니다.
 public class Main {
 
     public static void main(String[] args) throws Exception {
@@ -2339,7 +2339,7 @@ public class Main {
                 .usingJobData(jobDataMap)
                 .build();
                 
-        // SimpleTrigger 객체를 만들어 스케줄링 프로퍼티를 구성하고 마지막에 이 트리거로 잡을 싱핼할 스케줄러를 설정합니다.
+        // SimpleTrigger 객체를 만들어 스케쥴링 프로퍼티를 구성하고 마지막에 이 트리거로 잡을 싱핼할 스케쥴러를 설정합니다.
         Trigger trigger = TriggerBuilder.newTrigger()
                 .withIdentity("documentReplicationTrigger")
                 .startAt(new Date(System.currentTimeMillis() + 5000))
@@ -2349,7 +2349,7 @@ public class Main {
                         .repeatForever())
                 .build();
 
-        // 스케줄러 설정
+        // 스케쥴러 설정
         Scheduler scheduler = new StdSchedulerFactory().getScheduler();
         scheduler.start();
         scheduler.scheduleJob(job, trigger);
@@ -2406,7 +2406,7 @@ public class QuartzConfiguration {
     @Autowired
     // 쿼츠 트리거 구성
     // 스프링이 지원하는 트리거는 SimpleTriggerFactoryBean, CronTriggerFactoryBean  두 종류
-    // SimpleTriggerFactoryBean는 JobDetail 객체 레퍼린스를 필요로 하며 시작 시간이나 반복 횟수처럼 자주 쓰이는 스케줄러 프로퍼티 값을 설정 할 수있음
+    // SimpleTriggerFactoryBean는 JobDetail 객체 레퍼린스를 필요로 하며 시작 시간이나 반복 횟수처럼 자주 쓰이는 스케쥴러 프로퍼티 값을 설정 할 수있음
     public SimpleTriggerFactoryBean documentReplicationTrigger(JobDetail documentReplicationJob) {
         SimpleTriggerFactoryBean documentReplicationTrigger = new SimpleTriggerFactoryBean();
         documentReplicationTrigger.setJobDetail(documentReplicationJob);
@@ -2417,7 +2417,7 @@ public class QuartzConfiguration {
 
     @Bean
     @Autowired
-    // CronTriggerFactoryBean을 이용한 스케줄링 방식
+    // CronTriggerFactoryBean을 이용한 스케쥴링 방식
     public CronTriggerFactoryBean documentReplicationTrigger(JobDetail documentReplicationJob) {
         CronTriggerFactoryBean documentReplicationTrigger = new CronTriggerFactoryBean();
         documentReplicationTrigger.setJobDetail(documentReplicationJob);
@@ -2438,10 +2438,10 @@ public class QuartzConfiguration {
 }
 ```
 
-# [레시피 13-6] 스프링에서 작업 스케줄링하기
+# [레시피 13-6] 스프링에서 작업 스케쥴링하기
 
 ## 괘제
-쿼츠를 쓰지 않고 크론 표현식으로 주기나 빈도를 설정하여 일관된 방향으로 메서드가 실해 되도록 스케줄링 하고 싶습니다.
+쿼츠를 쓰지 않고 크론 표현식으로 주기나 빈도를 설정하여 일관된 방향으로 메서드가 실해 되도록 스케쥴링 하고 싶습니다.
 
 ## 해결책
 * 스프링 TaskExcutor와 TaskScheduler를 구성할 수 있게 지원합니다. 
@@ -2451,7 +2451,7 @@ public class QuartzConfiguration {
 ```java
 @Configuration
 @EnableScheduling
-// @EnableScheduling 애너테이션을 이용해서 스케줄링을 활성화
+// @EnableScheduling 애너테이션을 이용해서 스케쥴링을 활성화
 public class SchedulingConfiguration implements SchedulingConfigurer {
     @Override
     public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {