HOME > Detail View

Detail View

(Java 언어로 배우는)디자인 패턴 입문 : 멀티 쓰레드 편

(Java 언어로 배우는)디자인 패턴 입문 : 멀티 쓰레드 편 (Loan 21 times)

Material type
단행본
Personal Author
結城浩 조해미 , 역
Title Statement
(Java 언어로 배우는)디자인 패턴 입문 / 結城浩 저 ; 조해미 역 , 멀티 쓰레드 편.
Publication, Distribution, etc
서울 :   영진닷컴 ,   2003.  
Physical Medium
605 p. : 삽도 ; 24cm. + CD-ROM 1매.
Varied Title
Java言語で學ぶデザインパタ-ン入門  
ISBN
8931424477
General Note
찾아보기: p. [601]-605  
부록으로 "연습문제 해답"등 수록  
민기획 감수  
Bibliography, Etc. Note
참고문헌: p. 595-600
비통제주제어
computer programming ,,
000 01002camccc200325 k 4500
001 000045148478
005 20100806101445
007 ta
008 030430s2003 ulka 001a kor
020 ▼a 8931424477 ▼g 13000
035 ▼a KRIC08668878
040 ▼a HYUC ▼c HYUC ▼d 211062 ▼d 211009
041 1 ▼a kor ▼h jpn
082 0 4 ▼a 005.133 ▼2 22
090 ▼a 005.133 ▼b J41 2003zzp
100 1 ▼a 結城浩
245 2 0 ▼a (Java 언어로 배우는)디자인 패턴 입문 / ▼d 結城浩 저 ; ▼e 조해미 역 , ▼p 멀티 쓰레드 편.
246 1 9 ▼a Java言語で學ぶデザインパタ-ン入門  
260 ▼a 서울 : ▼b 영진닷컴 , ▼c 2003.
300 ▼a 605 p. : ▼b 삽도 ; ▼c 24cm. + ▼e CD-ROM 1매.
500 ▼a 찾아보기: p. [601]-605
500 ▼a 부록으로 "연습문제 해답"등 수록
500 ▼a 민기획 감수
504 ▼a 참고문헌: p. 595-600
653 ▼a computer programming
700 1 ▼a 조해미 , ▼e
900 1 1 ▼a Yuki, Hirosh
940 ▼a 자바언어데학부디자인입문
940 ▼a 자바언어로 배우는 디자인 패턴 입문

Holdings Information

No. Location Call Number Accession No. Availability Due Date Make a Reservation Service
No. 1 Location Science & Engineering Library/Stacks 5(Eastern Books)/ Call Number 005.133 J41 2003zzp Accession No. 121104070 Availability Available Due Date Make a Reservation Service B M
No. 2 Location Science & Engineering Library/Stacks 5(Eastern Books)/ Call Number 005.133 J41 2003zzp Accession No. 121104071 Availability Available Due Date Make a Reservation Service B M

Contents information

Book Introduction

멀티 쓰레드에 관심이 많은 자바 개발자들을 위한 책으로, 자바 언어를 통한 멀티 쓰레드와 병행 처리 패턴에 대해서 학습한다. 쓰레드의 기초 지식에서 시작하여 개시와 종료, 배타 제어와 협조 동작, 효과적인 사용법에 대해서 단계별로 학습한다.

저지르기 쉬운 실패나 멀티 쓰레드 프로그램을 읽을 때의 요점에 대한 내용을 따로 담았으며, 각 장의 마지막에는 독자들의 이해를 돕기 위한 연습문제를 담고 있다. 기본적으로 자바에 대한 지식을 필요로 한다.


Information Provided By: : Aladin

Author Introduction

유키 히로시(지은이)

1963년생. 프로그래밍과 암호, 수학 등에 관한 저서를 다수 집필했다. 같은 책을 몇 년에 걸쳐 읽고 또 읽는 것을 좋아하며, 바흐의 “푸가의 기법”과 “음악의 헌정”을 즐겨 듣는다. 프로그램 제작과 글쓰기가 취미이며 직업이기도 하다. 저서로는 ≪수학 걸≫ 시리즈와 ≪C 언어 프로그래밍 레슨 - 입문편, 문법편≫, ≪Perl 언어 프로그래밍 레슨 - 입문편≫, ≪JAVA 언어 프로그래밍 레슨(상·하)≫, ≪암호 기술 입문≫ 등이 있다.

Information Provided By: : Aladin

Table of Contents


목차
Introduction 01. 자바 언어의 쓰레드 = 33
 01. 자바 언어의 쓰레드 = 34
 02. 쓰레드라는 것은 무엇인가 = 34
  처리 흐름을 따라갈 때 우리들은 쓰레드를 따라가고 있다 = 34
  싱글 쓰레드 프로그램 = 35
  멀티 쓰레드 프로그램 = 37
  Thread 클래스의 run 메소드와 start 메소드 = 39
 03. 쓰레드의 기동 = 44
  쓰레드를 기동한다(1) - Thread 클래스의 서브 클래스를 사용한다 = 45
  쓰레드를 기동한다(2) - Runnable 인터페이스를 사용한다 = 47
 04. 쓰레드의 일시 정지 = 49
 05. 쓰레드의 배타 제어 = 51
  synchronized 메소드 = 53
  synchronized 블록 = 57
 06. 쓰레드의 협조 = 59
  wait 셋 - 쓰레드의 대합실 = 59
  wait 메소드 - 쓰레드를 wait셋에 넣는다 = 60
  notify 메소드 - 쓰레드를 wait셋에서 꺼낸다 = 62
  notifyAll 메소드 - 모든 쓰레드를 wait 셋에서 꺼낸다 = 65
  wait, notify, notifyAll은 Object 클래스의 메소드 = 67
 07. 쓰레드의 상태 변화 = 68
 08. 쓰레드를 둘러싸고 있는 그 밖의 화제 = 69
 09. 이 장에서 배운 것 = 69
 연습문제 = 70
Introduction 02. 멀티 쓰레드 프로그램의 평가 기준 = 75
 01. 멀티 쓰레드 프로그램의 평가 기준 = 76
  안전성 - 객체를 망가트리지 않을 것 = 76
  생존성 - 필요한 처리가 이루어질 것 = 77
  재사용성 - 클래스를 이용할 수 있을 것 = 77
  수행 능력 - 처리를 고속·대량으로 할 수 있을 것 = 78
  평가 기준의 정리 = 79
 02. 이 장에서 배운 것 = 79
 연습문제 = 80
Chapter 01. Single Threaded Execution - 이 다리를 건널 수 있는 사람은 오직 한 명 = 81
 01. Single Threaded Execution 패턴 = 82
 02. 예제 프로그램 1 : Single Threaded Execution 패턴을 사용하지 않는 예 = 82
  Main 클래스 = 83
  쓰레드 세이프가 아닌 Gate 클래스 = 84
  UserThread 클래스 = 86
  움직여보면… 망가져 버린다 = 87
  왜 망가지는 것일까? = 89
 03. 예제 프로그램 2 : Single Threaded Execution 패턴을 사용한 예 = 91
  쓰레드 세이프한 Gate 클래스 = 91
  Synchronized의 역할 = 92
 04. Single Threaded Execution 패턴의 등장인물 = 93
 05. 생각의 폭을 넓히기 위한 힌트 = 95
  어떤 때에 쓰는가(적용 가능성) = 95
  생존성과 데드락 = 97
  재사용성과 계승 이상 = 98
  크리티컬 섹션의 크기와 수행 능력 = 98
 06. 관련하고 있는 패턴 = 99
  Guarded Suspension 패턴 (제 3장) = 99
  Read-Write lock 패턴 (제 6장) = 99
  Read-Write lock 패턴 (제 6장) = 100
  Thread-Specific Storage 패턴 (제 11장) = 100
 07. 보강 : synchronized에 대해서 생각해 봅시다 = 100
  synchronized의 구분과 Before/After 패턴 = 100
  이 synchronized는 무엇을 지키고 있는 것일까 = 103
  어떤 단위로 지켜야 할까 = 104
  어느 락을 사용해서 지키고 있는가 = 104
  극소의 조작 = 105
  long과 double은 극소로 다루어지지 않는다 = 105
 08. 이 장에서 배운 것 = 107
 연습문제 = 108
Chapter 02. Immutable - 없애려고 해도 없어지지 않아 = 117
 01. Immutable 패턴 = 118
 02. 예제 프로그램 = 118
  lmmutable 패턴을 사용한 Person 클래스 = 119
  Main 클래스 = 120
  PrintPersonThread 클래스 = 121
 03. Immutable 패턴의 등장인물 = 124
 04. 생각의 폭을 넓히기 위한 힌트 = 125
  어떤 때에 사용하는 걸까 [적용 가능성] = 125
  mutable한 클래스와 Immutable한 클래스를 대조해 본다 [수행 능력] = 126
  불변성을 지키기 위해서 [재사용성] = 127
  표준 클래스 라이브러리에서 사용되는 Immutable 패턴 = 127
 05. 관련하고 있는 패턴 = 129
  Single Threaded Execution 패턴 (제 1장) = 129
  Read-Write Lock 패턴 (제 6장) = 129
  Flyweight 패턴 (부록F [GoF] [Yuki01] 참조) = 130
 06. 보강 : final = 130
  final의 의미 = 130
 07. 이 장에서 배운 것 = 132
 연습문제 = 133
Chapter 03. Guarded Suspension - 준비될 때까지 기다려요 = 139
 01. Guarded Suspension 패턴 = 140
 02. 예제 프로그램 = 140
  Request 클래스 = 142
  RequestQueue 클래스 = 142
  ClientThread 클래스 = 144
  ServerThread 클래스 = 145
  Main 클래스 = 145
  java.util.LinkedList 클래스의 역할 = 146
  getRequest 메소드를 자세히 읽는다 = 147
  putRequest 메소드를 자세히 읽는다 = 150
  synchronized의 의미 = 150
  wait와 락 = 151
 03. Guarded Suspension 패턴의 등장인물 = 151
 04. 생각의 폭을 넓히는 힌트 = 153
  조건부 synchronized = 153
  멀티 쓰레드 판의 if = 153
  상태 변경 잊어버리기와 생존성 = 153
  wait과 notify/notifyAll의 책임(재사용성) = 154
  여러 가지 통칭 = 154
 05. 관련하고 있는 패턴 = 156
  Single Threaded Execution 패턴 (제 1장) = 156
  Balking 패턴 (제 4장) = 156
  Producer-Consumer 패턴 (제 5장) = 157
  Future 패턴 (제 9장) = 157
 06. 이 장에서 배운 것 = 157
 연습문제 = 158
Chapter 04. Balking - 필요 없으면 관둬요 = 165
 01. Balking 패턴 = 166
 02. 예제 프로그램 = 166
  Data 클래스 = 167
  SaverThread 클래스 = 169
  ChangerThread 클래스 = 170
  Main 클래스 = 171
 03. Balking 패턴의 등장인물 = 174
 04. 생각의 폭을 넓히기 위한 힌트 = 175
  어떤 경우에 쓰는 것일까(적용 가능성) = 175
  balk 결과의 표현 방법 = 177
 05. 연관하고 있는 패턴 = 178
  Guarded Suspension 패턴 (제 3장) = 178
  Observer 패턴 (부록F [GoF] [Yuki01] 참조) = 178
 06. 보강 : 타임아웃 = 179
  Balking 패턴과 Guarded Suspension 패턴의 중간 = 179
  wait이 끝나는 것은 언제인가 = 179
  guarded timed의 구현 = 180
  synchronized에는 타임아웃이 없고 인터럽트도 될 수 없다 = 183
 07. 이 장에서 배운 것 = 184
 연습문제 = 185
Chapter 05. Producer - Consumer - 내가 만들고 당신이 쓰는 = 189
 01. 1Producer-Consumer 패턴 = 190
 02. 예제 프로그램 = 190
  Main 클래스 = 190
  MakerThread 클래스 = 192
  EaterThread 클래스 = 193
  Table 클래스 = 194
  put 메소드를 읽다 = 196
  take 메소드를 읽는다 = 198
 03. Producer-Consumer 패턴의 등장인물 = 200
 04. 생각의 폭을 넓히는 힌트 = 201
  안전성을 지키는 Channel [재사용성] = 201
  직접 건네주면 안될까 = 202
  Channel에 여유가 생긴다는 것 = 202
  어떤 순서로 Data를 건넬까 = 203
  「중개자의 존재」가 갖는 의미 = 204
  Consumer를 단수로 하면 어떻게 될까 = 205
 05. 연관하고 있는 패턴 = 206
  Mediator 패턴 (부록F [GoF] [Yuki01]참조) = 206
  Worker Thread 패턴 (제 8장) = 206
  Command 패턴 (부록F [GoF] [Yuki01]참조) = 206
  Strategy 패턴 (부록F [GoF] [Yuki01]참조) = 206
 06. 보강 : 예외 InterruptedException 이용 = 207
  시간은 걸릴지 몰라도 취소할 수 있다 = 207
  sleep 메소드와 interrupt 메소드 = 208
  wait 메소드와 interrupt 메소드 = 209
  join 메소드와 interrupt 메소드 = 210
  interrupt 메소드와 인터럽트 상태를 변경 = 211
  isInterrrupted 메소드 - 인터럽트 상태의 테스트 = 212
  Thread.interrupted 메소드 - 인터럽트 상태의 테스트와 클리어 = 211
  Thread 클래스의 stop 메소드를 사용해서는 안된다 = 212
 07. 이 장에서 배운 것 = 212
 연습문제 = 213
Chapter 06. Read-Write Lock - 모두 읽어도 좋지만 읽고 있을 때에는 쓰면 안돼요 = 219
 01. Read-Write Lock 패턴 = 220
 02. 예제 프로그램 = 221
  Main 클래스 = 221
  Data 클래스 = 222
  Writer Thread 클래스 = 226
  ReaderThread 클래스 = 227
  ReadWriteLock 클래스 = 228
  실행해 봅시다 = 230
  가드 조건의 확인 = 231
 03. Read-Write Lock 패턴의 등장인물 = 233
 04. 생각의 폭을 넓히기 위한 힌트 = 235
  읽기 처리가 중요할 때에 유효 = 235
  읽는 빈도가 쓰는 빈도보다도 높을 때의 유효 = 236
  락의 의미 = 236
 05. 관련하고 있는 패턴 = 237
  Immutable 패턴 (제 2장) = 237
  Single Threaded Execution 패턴 (제 1장) = 237
  Guarded Suspension 패턴(제 3장) = 237
  Before/After 패턴 (부록F [Lea] 참조) = 237
  Strategized Locking 패턴 (부록F [POSA2] 참조) = 238
 06. 이 장에서 배운 것 = 238
 연습문제 = 239
Chapter 07. Thread-Per-Message - 이 일 해두어야 해요 = 247
 01. Thread-Per-Message 패턴 = 248
 02. 예제 프로그램 = 248
  Main 클래스 = 249
  Host 클래스 = 250
  Helper 클래스 = 251
 03. Thread-Per-Message 패턴의 등장인물 = 255
 04. 생각의 폭을 넓히는 힌트 = 256
  응답성을 높이고 지연 시간을 줄인다 = 256
  처리의 순서를 신경 쓰지 않아도 될 때에 사용한다 = 256
  되돌아오는 값이 불필요한 경우에 사용한다 = 256
  서버에 응용하기 = 257
  메소드 호출 + 쓰레드 기동 → 메시지 송신 = 257
 05. 관련하고 있는 패턴 = 258
  Future 패턴 (제 9장) = 258
  Worker Thread 패턴 (제 8장) = 258
 06. 보강 : 프로세스와 쓰레드 = 259
 07. 이 장에서 배운 것 = 260
 연습문제 = 261
Chapter 08. worker Thread - 일이 올 때까지 기다리고 일이 오면 일한다 = 269
 01. Worker Thread 패턴 = 270
 02. 예제 프로그램 = 270
  Main 클래스 = 272
  ClientThread 클래스 = 273
  Request 클래스 = 273
  Channel 클래스 = 274
  WorkerThread 클래스 = 276
 03. worker Thread 패턴의 등장인물 = 278
 04. 생각의 폭을 넓히기 위한 힌트 = 279
  쓰레드 기동은 중요한 처리 = 279
  용량의 제어 = 280
  invocation과 execution의 분리 = 281
  Runnable 인터페이스의 의미 = 283
  다형적인 Request = 283
  한 명의 Worker = 285
 05. 관련하고 있는 패턴 = 285
  Producer-Consumer 패턴 (제 5장) = 285
  Thread-Per-Message 패턴 (제 7장) = 285
  Command 패턴 (부록F [GoF] [Yuki01] 참조) = 285
  Future 패턴 (제 9장) = 286
  Flyweight 패턴(부록F [GoF] [Yuki01] 참조) = 286
  Thread-Specific Storage 패턴 (제 11장) = 286
  Active Object 패턴 (제 12장) = 286
 06. 보강 : Swing의 이벤트·디스패칭·쓰레드 = 287
  이벤트·디스패칭·쓰레드라는 것은 무엇인가 = 287
  이벤트·디스패칭·쓰레드는 딱 한 명 = 288
  이벤트·디스패칭·쓰레드는 리스너를 호출한다 = 288
  리스너를 등록하는 것의 의미 = 290
  이벤트·디스패칭·쓰레드는 화면 그리기도 한다 = 290
  javax.swing.SwingUtilities 클래스 = 290
  Swing의 싱글 쓰레드 법칙 = 292
 07. 이 장에서 배운 것 = 293
 연습문제 = 294
Chapter 09. Future - 먼저 교환권을 가져가세요 = 299
 01. Future 패턴 = 300
 02. 예제 프로그램 = 300
  Main 클래스 = 303
  Host 클래스 = 304
  Data 인터페이스 = 305
  FutureData 클래스 = 306
  RealData 클래스 = 307
 03. Future 패턴의 등장인물 = 309
 04. 생각의 폭을 넓히는 힌트 = 311
  스루풋(throughput)은 향상하는 것일까 = 311
  비동기적인 메소드 호출의 「반환값」 = 312
  「되돌아오는 값의 준비」와 「반환값의 이용」을 분리 = 312
  변형 - 기다리게 하지 않는 Future = 313
  변형 - 변화하는 Future = 313
  멀티 쓰레드를 의식하고 있는 것은 누구인가 [재사용성] = 313
  콜백 Future 패턴 = 314
 05. 관련하고 있는 패턴 = 315
  Thread-per-Message 패턴 (제 7장) = 315
  Builder 패턴 (부록F [GoF] [Yuki01] 참조) = 315
  Proxy 패턴 (부록F [GoF] [Yuki01] 참조) = 315
  Guarded Suspension 패턴 (제 3장) = 315
  Balking 패턴 (제 4장) = 315
 06. 이 장에서 배운 것 = 316
 연습문제 = 316
Chapter 10. Two-Phase Termination - 뒷정리한 다음에 자도록 해요 = 323
 01. Two-phase Termination 패턴 = 324
 02. 예제 프로그램 = 325
  CountupThread 클래스 = 326
  Main 클래스 = 329
 03. Two-Phase Termination 패턴의 등장인물 = 331
 04. 생각의 폭을 넓히는 힌트 = 332
  Thread 클래스의 stop 메소드를 사용하면 안된다 = 332
  플래그 테스트만으로도 불충분 = 333
  인터럽트 상태의 테스트만으로도 불충분 = 333
  중요한 처리 전에 종료 요구를 체크 = 334
  join 메소드와 isAlive 메소드 = 335
  프로그램의 종료와 addShutdownHook 메소드 = 335
  우아하게 종료하는 쓰레드 = 337
 05. 관련하고 있는 패턴 = 338
  Before/After 패턴 (문제 6-5, 부록F [Lea] 참조) = 338
  Multiphase Cancellation 패턴 (부록F [Lea] 참조) = 338
  Multi-Phase Startup 패턴 = 338
  Balking 패턴 (제 4장) = 338
 06. 보강 : 인터럽트 상태와 예외 InterruptedException의 상호 변환 = 339
  인터럽트 상태 → 예외 InterruptedException로 변환 = 339
  예외 InterruptedException → 인터럽트 상태로의 변환 = 340
  예외 InterruptedException → 예외 InterruptedException로 변환 = 341
 07. 이 장에서 배운 것 = 342
 연습문제 = 342
Chapter 11. Thread-Specific Storage - 쓰레드마다 코인 락카 = 353
 01. Thread-Specific Storage 패턴 = 354
 02. java.lang.ThradLocal 클래스에 대해서 = 355
  java.lang.Threadlocal은 코인 락카룸 = 355
 03. 예제 프로그램1 : Thread-Specific Storage 패턴을 사용하지 않는 예 = 356
  Log 클래스 = 356
  Main 클래스 = 357
 04. 예제 프로그램2 : Thread-Specific Storage 패턴을 사용하고 있는 예 = 359
  쓰레드 고유의 TSLog 클래스 = 361
  Log 클래스 = 362
  ClientThread 클래스 = 363
  Main 클래스 = 364
 05. Thread-Specific Storage 패턴의 등장인물 = 365
 06. 생각의 폭을 넓히는 힌트 = 369
  지역 변수와 java.lang.ThreadLocal 클래스 = 369
  쓰레드 고유의 정보를 두는 장소 = 369
  다른 쓰레드에서 액세스된 걱정이 없다 = 370
  스루풋의 향상은 구현에 크게 의존한다 = 371
  컨텍스트의 위험성 = 372
 07. 관련하고 있는 패턴 = 373
  Singleton 패턴 (부록F [GoF] [Yuki01] 참조) = 373
  Worker Thread 패턴 (제 8장) = 373
  Single Threaded Execution 패턴 (제 1장) = 373
  Proxy 패턴 (부록F [GoF] [Yuki01] 참조) = 373
 08. 보강 : 액터·베이스와 태스크·베이스 = 374
  주체와 객체 = 374
  액터·베이스 = 375
  태스크·베이스 = 375
  실제로는 양쪽의 접근 방식이 혼재한다 = 376
 09. 이 장에서 배운 것 = 377
 연습문제 = 378
Chapter 12. Active Object - 비동기 메시지를 받아들이는 능동적 객체 = 381
 01. Active Object 패턴 = 382
 02. 예제 프로그램 = 383
  이용측 : Main 클래스 = 386
  이용측 : MakerClientThread 클래스 = 386
  이용측 : DisplayClientThread 클래스 = 388
  「능동적 객체」측 : ActiveObject 인터페이스 = 389
  「능동적 객체」측 : ActiveObjectFactory 클래스 = 389
  「능동적 객체」측 : Proxy 클래스 = 390
  「능동적 객체」측 : SchedulerThread 클래스 = 392
  「능동적 객체」측 : ActivationQueue 클래스 = 393
  「능동적 객체」측 : MethodRequest 클래스 = 395
  「능동적 객체」측 : MakeStringRequest 클래스 = 395
  「능동적 객체」측 : DisplayStringRequest 클래스 = 397
  「능동적 객체」 : Result 클래스 = 397
  「능동적 객체」측 : FutureResult 클래스 = 398
  「능동적 객체」측 : RealResult 클래스 = 399
  「능동적 객체」측 : Servant 클래스 = 399
  예제 프로그램의 실행 = 400
 03. Active Object 패턴의 등장인물 = 402
 04. 생각의 폭을 넓히기 위한 힌트 = 405
  결국 무엇을 한 것이 되는 걸까 = 405
  패턴의 적용에는 문제의 규모를 생각해서 = 409
  병행성에 주목 = 409
  메소드를 추가한다 = 410
  Scheduler의 역할 = 411
  「능동적 객체」끼리의 대화 = 412
  분산 처리에서 - 쓰레드의 경계를 머신의 경계로 옮긴다 = 412
 05. 관련하고 있는 패턴 = 413
  Producer-Consumer 패턴 (제 5장) = 413
  Future 패턴 (제 9장) = 413
  Worker Thread 패턴 (제 8장) = 413
  Thread-Specific Storage 패턴 (제 11장) = 413
 06. 이 장에서 배운 것 = 413
 연습문제 = 415
Chapter 13. 정리 - 멀티 쓰레드 프로그래밍의 패턴·언어 = 419
 01. 멀티 쓰레드 프로그래밍의 패턴·언어 = 420
  패턴과 패턴·언어 = 420
 02. Single Threaded Execution 패턴 (제1장) = 422
  이 다리를 건널 수 있는 사람은 오직 한 명 = 422
 03. Single Threaded Execution 패턴 (제 2장) = 423
  없애려고 해도 없어지지 않아 = 423
 04. Guarded Suspension 패턴 (제 3장) = 424
  준비될 때까지 기다려요 = 424
 05. Balking 패턴 (제 4장) = 425
  필요 없으면 관둬요 = 425
 06. Producer-Consumer 패턴 (제 5장) = 426
  내가 만들고 당신이 쓰는 = 426
 07. Read-Write Lock 패턴 (제 6장) = 427
  모두 읽어도 좋지만 읽고 있을 때에는 쓰면 안돼요 = 427
 08. Thread-Per-Message 패턴 (제 7장) = 428
  이 일은 해두어야 해요 = 428
 09. Worker Thread 패턴 (제 8장) = 429
  일이 올 때까지 기다리고 일이 오면 일한다 = 429
 10. Future 패턴 (제 9장) = 430
  먼저 교환권을 가져가세요 = 430
 11. Two-Phase Termination 패턴 (제 10장) = 431
  뒷정리한 다음에 자도록 해요 = 431
 12. Thread-Specific Storage 패턴 (제 11장) = 432
  쓰레드마다 코인 락카 = 432
 13. Active Object 패턴 (제 12장) = 433
  비동기 메시지를 받아들이는 능동적인 객체 = 433
 14. 마지막으로 = 434
Appendix = 435
 부록 A. 연습문제 해답 = 436
 부록 B. 자바의 메모리 모델 = 570
 부록 C. 자바 쓰레드의 우선순위 = 585
 부록 D. 쓰레드 관련 주요 API = 586
 부록 E. 예제 프로그램의 실행 순서 = 592
 부록 F. 참고 문헌 = 595


New Arrivals Books in Related Fields