자바는 언어 차원에서 멀티 스레드를 지원한다. C/C++은 멀티 스레드에 안정적인 구조만 제공할 뿐 멀티 스레드 자체는 제공하지 않는다. 스레드는 운영체제 수준에서 제공되는 것이 원칙적이지만 자바의 경우는 가상 머신이 미니 운영체제이므로 언어가 직접적으로 스레드를 지원할 수 있다.
스레드를 지원한다는 것은 한번에 여러 가지 일을 동시에 수행할 수 있다는 뜻이다. 최초 실행을 시작할 때는 main 스레드 하나밖에 없지만 추가로 더 만들 수 있다. 추가 생성된 작업 스레드는 기본적으로 메인과 같은 레벨이다. 스레드끼리는 평등해서 모든 스레드가 종료되어야 프로그램이 종료된다. Win32 환경의 스레드와는 좀 다른데 Win32에서는 메인이 종료되면 작업 스레드는 강제 종료된다.
메인의 종료되면 강제로 종료되는 스레드도 만들 수 있는데 이런 스레드를 데몬 스레드라고 한다. 데몬 스레드로 만들려면 스레드를 시작하기 전에 setDaemon(true)를 호출하면 된다. 단순한 장식을 위한 애니메이션 처리나 정보의 저장과 전혀 상관없는 정렬 루틴 등의 작업은 데몬 스레드로 생성한다.
자바에서는 스레드도 하나의 클래스로 표현되므로 스레드별로 별도의 클래스를 정의해야 한다. Thread 클래스로부터 상속을 받아 run 메서드를 재정의한다. 외부에서 호출할 수 있어야 하므로 반드시 public이어야 하며 리턴값은 가지지 않는다. run 메서드는 스레드의 진입점이며 이 메서드에서 스레드의 작업을 처리한다. run 메서드가 리턴하면 스레드도 종료한다.
메인에서는 스레드를 생성 및 실행한다. 스레드 객체를 선언한 후 new 연산자로 생성하며 필요하다면 생성자로 스레드 동작에 필요한 인수를 전달할 수 있다. 스레드 객체 생성 후에 우선 순위나 이름 등의 속성을 설정할 수 있는데 디폴트도 무난하다. 그리고 start 메서드를 호출하는데 start에 의해 스레드를 위한 스택 등의 실행 환경이 만들어지고 run 메서드가 호출된다.
이후 메인 스레드와 작업 스레드는 별도의 실행 흐름을 가지며 동시에 실행된다. JVM은 CPU의 시간을 잘게 쪼개어 스레드를 번갈아 가며 실행하여 동시에 실행되는 것처럼 보이게 한다. 이런 방식을 라운드 로빈이라고 한다. 간단한 예제를 만들어 보자. 텍스트 환경에서는 멀티 스레드를 실용적으로 사용할만한 예가 없어 문자열만 출력해 보았다.
public class JavaExam {
public static void main(String[] args) {
MyThread worker = new MyThread();
worker.start();
for (int num = 0;num < 20;num++) {
try { Thread.sleep(50); } catch (InterruptedException e) { ; }
System.out.print("Java ");
}
}
}
class MyThread extends Thread {
public void run() {
for (int num = 0;num < 20;num++) {
try { Thread.sleep(30); } catch (InterruptedException e) { ; }
System.out.print("자바 ");
}
}
}
MyThread의 run 메서드는 0.03초에 한번씩 "자바"라는 문자열을 출력한다. 메인 스레드는 0.05초에 한번씩 "Java"라는 문자열을 출력한다. 두 스레드가 교대로 실행되는 것을 확인해 보기 위해 각 동작 한번당 조금씩 쉬도록 했는데 이때는 다음 정적 메서드를 호출한다.
static void sleep(long millis)
static void yield()
1/1000초 단위로 시간을 지정하면 이 시간만큼 스레드는 실행을 중지하고 잠시 쉰다. sleep 실행중에 예외가 발생할 수 있으므로 반드시 try 블록으로 묶어야 한다. yield는 현재 할당된 시간만 포기하고 다른 스레드로 실행 시간을 양보한다. 실행 결과는 다음과 같다.
자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 자바 Java 자바 Java Java Java Java Java Java Java Java Java Java
두 문자열이 불규칙하게 섞여서 출력되는 것을 보면 교대로 실행되는 것을 알 수 있다. 각 스레드는 CPU 시간을 공평하게 분배 받지만 작업 스레드는 0.03초를 쉬고 메인 스레드는 0.05초를 쉬므로 작업 스레드가 더 많은 시간을 사용한다. 다음 두 메서드는 스레드의 속성을 설정한다.
void setPriority(int newPriority)
void setName(String name)
우선 순위는 MIN_PRIORITY, NORM_PRIORITY, MAX_PRIORITY 중 하나를 지정한다. 별 지정이 없으면 이 스레드를 생성한 스레드의 우선 순위대로 생성된다. 우선 순위를 임의로 변경하면 JVM의 정교한 스케줄링 알고리즘에 방해가 되므로 왠만하면 건드리지 않는 것이 좋다. 스레드의 이름은 디버깅이나 정보 출력용으로 사용되며 실행과는 상관이 없다.
스레드를 생성하는 또 다른 방법은 Runnable 인터페이스를 구현하는 것이다. Runnable 인터페이스의 run 메서드 안에서 코드를 실행한다. 앞 예제와 똑같은 예제를 만들어 보자.
public class JavaExam {
public static void main(String[] args) {
MyRunnable MyRun = new MyRunnable();
Thread worker = new Thread(MyRun);
worker.start();
for (int num = 0;num < 20;num++) {
try { Thread.sleep(50); } catch (InterruptedException e) { ; }
System.out.print("Java ");
}
}
}
class MyRunnable implements Runnable {
public void run() {
for (int num = 0;num < 20;num++) {
try { Thread.sleep(30); } catch (InterruptedException e) { ; }
System.out.print("자바 ");
}
}
}
MyRunnable 클래스는 Runnable 인터페이스의 run 메서드를 구현한다. main에서 MyRunnable 객체를 생성한 후 Thread의 생성자로 넘기면 이 객체의 run 메서드가 스레드의 진입점으로 사용된다. 이후 스레드 객체의 start 메서드를 호출하면 새로운 스레드가 생성되며 러너블 객체의 run 메서드가 실행을 시작한다.
Thread 클래스로부터 상속을 받는 방법에 비해 약간 번거롭고 직관적이지 못하다. 이 방법이 필요한 이유는 자바가 다중 상속을 지원하지 않기 때문이다. 다음 예제를 보자.
public class JavaExam {
public static void main(String[] args) {
MyRunnable MyRun = new MyRunnable();
Thread worker = new Thread(MyRun);
worker.start();
for (int num = 0;num < 20;num++) {
try { Thread.sleep(50); } catch (InterruptedException e) { ; }
System.out.print("Java ");
}
}
}
class MyClass {
public void PrintJava() {
for (int num = 0;num < 20;num++) {
try { Thread.sleep(30); } catch (InterruptedException e) { ; }
System.out.print("자바 ");
}
}
}
class MyRunnable extends MyClass implements Runnable {
public void run() {
PrintJava();
}
}
이 예제의 MyClass는 PrintJava라는 메서드를 가진다. 이 클래스를 상속받아 조금 다르게 동작하도록 만든 후 별도의 스레드에서 실행하고 싶다고 하자. MyClass를 수정하려면 이 클래스를 상속 받아야 하고 스레드에서 실행하고 싶으면 Thread로부터도 상속을 받아야 한다. 원하는대로 하자면 다음 구문이 필요하다.
class MyThread extends MyClass extends Thread {
자바는 이런 다중 상속을 지원하지 않는다. 그래서 run 메서드를 가지는 인터페이스를 대신 제공하는 것이다. 인터페이스로부터 run 메서드를 상속받아 구현한 후 스레드의 생성자로 넘기면 스레드가 run 메서드를 진입점으로 사용한다.
참고로 앞의 Runnable 사용 예제는 익명 이너 클래스를 사용하면 좀 더 간단하게 작성할 수 있다. 딱 하나의 객체만 생성하므로 굳이 MyRunnable이라는 클래스를 정의할 필요없이 익명의 클래스로부터 생성된 정적 멤버를 선언하면 된다.
public class JavaExam {
public static void main(String[] args) {
Thread worker = new Thread(mRunnable);
worker.start();
for (int num = 0;num < 20;num++) {
try { Thread.sleep(50); } catch (InterruptedException e) { ; }
System.out.print("Java ");
}
}
static Runnable mRunnable = new Runnable() {
public void run() {
for (int num = 0;num < 20;num++) {
try { Thread.sleep(30); } catch (InterruptedException e) { ; }
System.out.print("자바 ");
}
}
};
}
딱 하나의 객체만 필요하므로 굳이 객체를 생성하거나 static으로 선언할 필요없이 객체 생성문을 Thread의 생성자 안에 집어 넣어 버리면 더 간단하게 줄일 수도 있다.
public class JavaExam {
public static void main(String[] args) {
Thread worker = new Thread(new Runnable() {
public void run() {
for (int num = 0;num < 20;num++) {
try { Thread.sleep(30); } catch (InterruptedException e) { ; }
System.out.print("자바 ");
}
}
});
worker.start();
for (int num = 0;num < 20;num++) {
try { Thread.sleep(50); } catch (InterruptedException e) { ; }
System.out.print("Java ");
}
}
}
길이는 훨씬 더 짧아졌지만 이런 구문을 처음 보는 초보자에게는 상당히 어려워 보인다. AWT에서는 이런 방식을 흔하게 사용한다.
스레드는 보통 상호 완전히 독립적인 작업을 담당한다. 예를 들어 화면 장식을 위한 애니메이션 스레드와 인쇄 스레드는 아무 상관이 없다. 이럴 때는 스레드끼리 서로의 실행 방식이나 작업 결과에 신경쓸 필요가 없고 심지어 서로의 존재를 몰라도 상관없다.
그러나 때로는 연관된 작업을 분담하여 실행하기도 하는데 이때는 공유하는 데이터가 있기 마련이며 이 데이터를 적절히 관리하기 위해 서로 통신을 해야 한다. 전형적인 예는 다운로드 스레드와 다운로드된 데이터를 사용하는 스레드이다. 예를 들어 동영상을 다운로드 하는 스레드가 있고 다운로드 받은 동영상의 미리 보기를 출력하는 스레드가 있다고 하자.
다운로드 받은 동영상을 저장하는 장소와 미리 보기를 할 동영상이 있는 장소가 같으므로 어디까지 받았는지, 받은 데이터가 무엇인지를 알려 주어야 한다. 스레드끼리 공유할 데이터를 객체로 만든 후 양쪽 스레드에게 전달한다. 기본형은 사본이 전달되므로 공유 데이터로 사용할 수 없으며 위치가 전달되는 참조형만 공유 데이터로 사용할 수 있다.
다음 예제의 DownLoad 스레드는 동영상을 다운로드 하며 Play 스레드는 다운로드중인 동영상을 재생한다. 콘솔 환경에서 동영상을 재생할 수는 없으므로 정수형 데이터를 동영상으로 가정하여 설명하기로 한다.
public class JavaExam {
public static void main(String[] args) {
Memory mem = new Memory(16);
DownLoad down = new DownLoad(mem);
Play play = new Play(mem);
down.start();
play.start();
}
}
class Memory {
int[] buffer;
int size;
int progress;
Memory(int asize) {
size = asize;
buffer = new int[asize];
progress = 0;
}
}
class DownLoad extends Thread {
Memory mem;
DownLoad(Memory amem) {
mem = amem;
}
public void run() {
for (int off = 0;off < mem.size;off++) {
mem.buffer[off] = off;
mem.progress = off + 1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
}
class Play extends Thread {
Memory mem;
Play(Memory amem) {
mem = amem;
}
public void run() {
for (;;) {
for (int off = 0;off < mem.progress;off++) {
System.out.print(mem.buffer[off] + " ");
}
System.out.println();
if (mem.progress == mem.size) break;
try { Thread.sleep(500); } catch (InterruptedException e) { ; }
}
}
}
이 예제의 Memory 클래스가 공유 데이터이다. 다운로드 받을 동영상의 길이에 해당하는 buffer 배열을 가지며 버퍼 크기와 다운로드 진행 상황을 size, progress 필드에 기억한다. 생성자에서는 전달받은 길이대로 버퍼를 미리 할당해 놓으며 progress는 0으로 초기화한다.
메인 스레드에서는 길이 16의 공유 버퍼 객체를 생성하되 이 객체를 DownLoad와 Play 스레드의 생성자로 전달한다. 각 스레드는 mem이라는 이름으로 공유 객체에 대한 참조를 저장하여 이후의 통신을 준비한다. 참조형이므로 사본이 생성되는 것이 아니라 같은 객체를 가리키고 있으며 따라서 한쪽에서 변경하면 다른쪽에서 즉시 변경된 내용을 읽을 수 있다.
DownLoad 스레드의 run 메서드에서는 버퍼의 길이만큼 루프를 돌며 다운로드를 받는다. 실제 네트워크에 접속하는 것이 아니라 단순히 버퍼의 배열 첨자를 집어 넣어 다운로드 받은 흉내만 낸다. 한번에 1바이트씩 받으며 progress에 어디까지 받았는지 기록해 놓는다. 루프 내부에서 0.2초씩 쉬어 네트워크 속도가 느린 것처럼 했다.
Paly 메서드는 progress까지, 즉 다운로드 스레드가 받은 양만큼 버퍼를 덤프하여 어디까지를 받았는지 보여준다. 무한 루프를 돌며 다 받을 때까지 0.5초에 한번씩 미리 보기를 출력하도록 했다. 미리 보기를 너무 자주 보여줄 필요는 없다. 실행 결과는 다음과 같은데 스레드의 실행 시간이 시스템 상황에 따라 달라지므로 완전히 똑같은 결과가 나오지는 않는다.
0
0 1 2
0 1 2 3 4 5
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7 8 9 10 11 12
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
다운로드 스레드는 buffer에 열심히 다운로드만 받고 Play 스레드는 다운로드 스레드가 받아 놓은 만큼만 보여 준다. 다운로드 받은 동영상 정보와 어디까지 다운로드를 받았는지는 mem 공유 객체를 참조한다. 한쪽에서는 열심히 쓰고 한쪽에서는 열심히 읽는 것이다.
스레드는 각자 독립적으로 실행되므로 스레드의 실행 순서나 실행 시간은 전혀 예측할 수 없으며 통제할 수도 없다. 그러다 보면 데이터가 아직 준비되지 않은 상황인데도 스레드가 실행되어 엉뚱한 결과가 나오기도 한다. 앞 예제를 다음과 같이 수정해 보자.
class DownLoad extends Thread {
Memory mem;
DownLoad(Memory amem) {
mem = amem;
}
public void run() {
for (int off = 0;off < mem.size;off += 2) {
for (int chunk = 0;chunk < 2;chunk++) {
mem.buffer[off+chunk] = off+chunk;
mem.progress = off+chunk+1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
}
}
다운로드 스레드의 코드가 조금 바뀌었는데 동영상을 1바이트씩 받지 않고 한번에 2바이트씩 받는다. 동영상같은 압축 파일은 내부에 블록이 나누어져 있으며 한 블록은 여러 개의 청크로 구성된다. 위 코드는 2바이트를 한 블록으로 가정하고 블록 단위로 다운로드 받는 것을 흉내낸 것이다.
이렇게 되면 미리 보기 스레드도 한 블록을 다 받았을 때만 실행되어야 한다. 반쪽짜리 블록은 완전한 데이터가 아니므로 미리 보기를 할 수 없다. 억지로 만든 설정이라 직관적이지는 못하지만 짝수 바이트로 받았을 때만 미리 보기가 가능하다고 하자. 이 상태에서 실행해 보면 원하는대로 동작하지 않는다.
0 1 2
0 1 2 3 4 5
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
짝수개가 나올 때도 있지만 홀수개가 나오기도 한다. 왜냐하면 두 스레드가 언제 실행될지 전혀 예측할 수 없기 때문이다. DownLoad가 한 블록을 받고 있는 중간에 Play 스레드가 제어권을 받으면 미완성된 블록이 보인다. 이 예제의 경우는 단순한 숫자라 별 이상없지만 진짜 동영상이라면 아직 덜 받은 데이터의 압축을 풀다가 다운될 수도 있다.
문제를 해결하려면 한 블록을 다 받기 전에는 재생을 하지 못하도록 해야 한다. 공유 객체를 두 스레드가 무작위로 읽고 써서는 안되며 번갈아 가며 사용해야 한다. 한쪽에서 쓰고 있는 동안에는 다른 쪽에서 읽지 못하고 반대로 읽고 있는 동안에는 쓰지 못하도록 해야 한다. 두 스레드가 동시에 진입할 수 없는 영역을 크리티컬 섹션이라고 한다. 크리티컬 섹션을 만들 때는 다음 구문을 사용한다.
synchronized (공유객체) {
// 이 영역이 크리티컬 섹션
}
공유 객체는 보호하고자 하는 정보이며 양쪽에서 액세스 가능해야 한다. 이 예제의 경우 mem이 바로 공유 객체이다. 두 스레드를 다음과 같이 수정해 보자.
class DownLoad extends Thread {
Memory mem;
DownLoad(Memory amem) {
mem = amem;
}
public void run() {
for (int off = 0;off < mem.size;off += 2) {
synchronized(mem) {
for (int chunk = 0;chunk < 2;chunk++) {
mem.buffer[off+chunk] = off+chunk;
mem.progress = off+chunk+1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
}
}
}
class Play extends Thread {
Memory mem;
Play(Memory amem) {
mem = amem;
}
public void run() {
for (;;) {
synchronized(mem) {
for (int off = 0;off < mem.progress;off++) {
System.out.print(mem.buffer[off] + " ");
}
System.out.println();
}
if (mem.progress == mem.size) break;
try { Thread.sleep(500); } catch (InterruptedException e) { ; }
}
}
}
mem 객체를 액세스하는 부분을 크리티컬 섹션으로 둘러쌌다. 이렇게 되면 한번에 한 스레드만 크리티컬 섹션으로 들어갈 수 있다. 만약 다운로드 스레드가 쓰기를 하고 있다면 재생 스레드는 쓰기가 끝날 때까지 기다린다. 한 블록이 완성될 때만 재생을 하므로 불완전한 동영상을 보여 주지 않는다. 마찬가지로 재생을 하는 동안에는 다운로드 스레드도 잠시 중지하고 재생이 완료될 때까지 기다린다. 실행해 보자.
0 1 2 3 4 5
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
실행할 때만 결과는 조금씩 달라지겠지만 항상 짝수개만 출력될 것이다.
다운로드를 받는 동작과 재생을 하는 동작은 모두 Memory 객체를 대상으로 한다. 그래서 두 동작을 Memory 클래스안의 메서드로 캡슐화하고 스레드에서는 공유 객체의 메서드만 호출하면 된다. 다음과 같이 수정해 보자.
public class JavaExam {
public static void main(String[] args) {
Memory mem = new Memory(16);
DownLoad down = new DownLoad(mem);
Play play = new Play(mem);
down.start();
play.start();
}
}
class Memory {
int[] buffer;
int size;
int progress;
Memory(int asize) {
size = asize;
buffer = new int[asize];
progress = 0;
}
void DownChunk(int off) {
for (int chunk = 0;chunk < 2;chunk++) {
buffer[off+chunk] = off+chunk;
progress = off+chunk+1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
void PlayDowned() {
for (int off = 0;off < progress;off++) {
System.out.print(buffer[off] + " ");
}
System.out.println();
}
}
class DownLoad extends Thread {
Memory mem;
DownLoad(Memory amem) {
mem = amem;
}
public void run() {
for (int off = 0;off < mem.size;off += 2) {
mem.DownChunk(off);
}
}
}
class Play extends Thread {
Memory mem;
Play(Memory amem) {
mem = amem;
}
public void run() {
for (;;) {
mem.PlayDowned();
if (mem.progress == mem.size) break;
try { Thread.sleep(500); } catch (InterruptedException e) { ; }
}
}
}
같은 예제를 다른 형식으로 작성한 것이다. 크리티컬 섹션으로 보호하지 않았으므로 동기화 문제가 발생한다. DownChunk가 반만 받았을 때 PlayDowned가 실행될 수 있다. 이 메서드안을 크리티컬 섹션으로 감싸야 한다.
void DownChunk(int off) {
synchronized(this) {
for (int chunk = 0;chunk < 2;chunk++) {
buffer[off+chunk] = off+chunk;
progress = off+chunk+1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
}
void PlayDowned() {
synchronized(this) {
for (int off = 0;off < progress;off++) {
System.out.print(buffer[off] + " ");
}
System.out.println();
}
}
이때 동기화 객체는 바로 자기 자신이므로 this라고 지정하면 된다. 제대로 동기화된다. 메서드의 본체 전체가 this에 대해 크리티컬 섹션을 지정할 때는 다음과 같이 좀 더 간단하게 표기할 수 있다.
class Memory {
int[] buffer;
int size;
int progress;
Memory(int asize) {
size = asize;
buffer = new int[asize];
progress = 0;
}
synchronized void DownChunk(int off) {
for (int chunk = 0;chunk < 2;chunk++) {
buffer[off+chunk] = off+chunk;
progress = off+chunk+1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
}
synchronized void PlayDowned() {
for (int off = 0;off < progress;off++) {
System.out.print(buffer[off] + " ");
}
System.out.println();
}
}
메서드 선언문 앞에 syncronized 키워드를 붙이면 이 메서드의 본체 전체가 this에 대해 크리티컬 섹션으로 인식된다. 즉 다음 두 형식은 같다.
|
void Method() { synchronized(this) { // 본체 } } |
synchronized void Method() { // 본체 } |
이렇게 선언된 메서드를 동기화 메서드라고 한다. 동기화 메서드는 어떤 스레드에서 호출하든지 한번에 하나만 실행될 수 있다. DownChunk가 다운로드를 받고 있는 중이라면 어떤 스레드에서 호출하건 PlayDowned는 대기한다.
예제의 요구 사항을 조금 바꾸어 Play 메서드는 다운로드 중의 미리 보기를 재생하는 것이 아니라 다운로드 완료된 동영상만 재생한다고 해 보자. 다운로드가 완료되기 전에는 재생을 시작해서는 안된다. 다음과 같은 방법을 생각할 수 있다.
class Play extends Thread {
Memory mem;
Play(Memory amem) {
mem = amem;
}
public void run() {
while (mem.progress != mem.size) {;}
for (int off = 0;off < mem.progress;off++) {
System.out.print(mem.buffer[off] + " ");
}
System.out.println();
}
}
run 메서드의 선두에서 다운로드가 완료될 때까지 빈 루프를 돌며 기다리면 된다. 이렇게 해도 대기의 목적은 달성할 수 있다. 그러나 대기하는 스레드가 빈 루프를 돌리느라 너무 많은 CPU 시간을 소모한다. 전체적인 다운로드도 늦어질 것이다. 좀 더 효율적인 대기 방법이 필요한데 이때는 다음 메서드를 사용한다.
void wait()
void notify()
이 두 메서드는 Object 소속이므로 모든 클래스가 이 메서드를 제공한다. 주로 공유 객체에 대해서 이 메서드를 사용한다. wait 메서드는 공유 객체를 사용할 수 있을 때까지 대기한다. CPU 시간을 소모하지 않으며 다른 스레드로 실행 시간을 양보한다.
notify 메서드는 공유 객체를 사용할 수 있는 상태라는 것을 알린다. notify를 호출하면 공유 객체를 기다리던 스레드가 실행을 시작한다. 두 문장은 모두 동기화 블록에 있어야 하며 wait는 예외 발생 가능성이 있어 try 블록 안에도 포함되어 있어야 한다. 예제를 다음과 같이 수정해 보자.
class DownLoad extends Thread {
Memory mem;
DownLoad(Memory amem) {
mem = amem;
}
public void run() {
for (int off = 0;off < mem.size;off++) {
mem.buffer[off] = off;
mem.progress = off + 1;
try { Thread.sleep(200); } catch (InterruptedException e) { ; }
}
synchronized(mem) { mem.notify(); }
}
}
class Play extends Thread {
Memory mem;
Play(Memory amem) {
mem = amem;
}
public void run() {
try {
synchronized(mem) { mem.wait(); }
} catch(InterruptedException e) { }
for (int off = 0;off < mem.progress;off++) {
System.out.print(mem.buffer[off] + " ");
}
System.out.println();
}
}
최초 두 스레드가 동시에 실행되지만 mem 공유 객체가 아직 덜 만들어졌으므로 Play 스레드는 이 객체를 사용할 수 있을 때까지 대기한다. DownLoad 스레드는 다운로드를 다 받은 후 mem의 notify를 호출하여 이 공유 객체를 사용할 수 있음을 알린다. Play 스레드는 동영상을 다 받은 후에나 재생을 시작할 것이다.
wait 메서드의 인수로 타임 아웃을 지정할 수 있다. 타임 아웃이 경과되어도 공유 객체를 사용할 수 없는 상태이면 더 이상 대기하지 않고 그냥 리턴한다. 여러 개의 스레드가 하나의 공유 객체를 기다리고 있을 수도 있다. 이 상황에서 notify를 호출하면 최초로 실행되는 스레드 하나만 깨어난다. 이에 비해 notifyAll 메서드는 공유 객체를 기다리는 모든 스레드에게 한꺼번에 신호를 보낸다.
자바 5.0에서 새로 추가된 getState 메서드는 스레드의 현재 상태를 조사하는데 시스템 상태를 모니터링 하는데 주로 사용된다. suspend, resume, stop 등의 메소드는 스레드를 일시 중지, 재개, 중지 시키는데 데드락의 위험이 있으므로 지금은 사용이 권장되지 않는다. 이 메소드 대신 변수를 사용하는 것이 좋다.