Runnable을 만드는 세 가지 방법과 람다 캡처
같은 작업을 정적 중첩 클래스, 익명 클래스, 람다로 만들어 비교하고, 람다가 지역 변수를 캡처하는 규칙과 작업 객체 하나를 여러 스레드가 함께 쓸 때 생기는 문제를 배웁니다.
앞 글에서는 스레드가 할 일을 Runnable로 떼어 Thread 생성자에 넘겼습니다. 반복문에서 스레드를 여러 개 만들 때는 대개 람다로 작업을 그 자리에서 만드는데, 반복 변수를 람다 안에서 쓰려는 순간 컴파일 오류가 납니다. 오류를 피하려고 값을 배열에 담으면 컴파일은 되지만, 이번에는 스레드들이 엉뚱한 값을 보거나 셈이 틀어집니다. 두 문제 모두 작업 객체가 바깥의 무엇을 붙잡고 있는지에서 나옵니다.
이 글을 읽고 나면 다음을 할 수 있습니다.
- 같은 작업을 이름 있는 클래스, 익명 클래스, 람다로 만들고 상황에 맞는 문법을 고릅니다.
- 반복문에서 람다가 회차마다 다른 값을 캡처하도록 고칩니다.
- 작업 객체 하나를 여러 스레드가 함께 써서 값이 사라지는 문제를 재현하고, 공유를 없애 고칩니다.
앞 글과 같은 java-board 폴더에서 작업합니다. 첫 예제는 src/RunnableStyleCatalog.java에 저장하고 javac -d out src/RunnableStyleCatalog.java로 컴파일한 뒤 java -cp out RunnableStyleCatalog로 실행합니다. 다른 예제도 코드 블록 제목의 경로에 저장하고 같은 방식으로 실행합니다. 세 문법 자체는 11장의 정적 중첩 클래스와 익명 클래스에서 이미 보았습니다.
세 가지 문법으로 같은 작업 만들기
Runnable에는 추상 메서드가 run() 하나뿐이어서 함수형 인터페이스(functional interface)에 해당합니다. 그래서 이름 있는 클래스로도, 익명 클래스로도, 람다식으로도 만들 수 있습니다. 아래 프로그램은 '현재 스레드 이름=값'을 한 줄 출력하는 작업을 세 문법으로 만들고, 각각 다른 스레드에서 실행합니다. NamedTask는 Runnable을 구현한 정적 중첩 클래스로 출력할 값을 생성자로 받아 필드에 담아 두고, 두 번째 작업은 Thread 생성자의 인수 자리에서 바로 만든 익명 클래스, 세 번째는 람다식입니다.
public final class RunnableStyleCatalog {
private static final class NamedTask implements Runnable {
private final String value;
NamedTask(String value) {
this.value = value;
}
public void run() {
print(value);
}
}
private static void print(String value) {
System.out.println(Thread.currentThread().getName() + "=" + value);
}
public static void main(String[] args) throws InterruptedException {
Thread named = new Thread(new NamedTask("class"), "style-1");
Thread anonymous =
new Thread(
new Runnable() {
public void run() {
print("anonymous");
}
},
"style-2");
Thread lambda = new Thread(() -> print("lambda"), "style-3");
Thread[] all = {named, anonymous, lambda};
for (Thread worker : all) {
worker.start();
}
for (Thread worker : all) {
worker.join();
}
}
}style-1=class
style-3=lambda
style-2=anonymous각 줄에서 스레드 이름과 값의 짝은 언제나 같습니다. style-1 스레드에는 NamedTask("class")를, style-3 스레드에는 print("lambda")를 호출하는 람다를 넘겼기 때문입니다. 반면 줄의 순서는 실행할 때마다 달라질 수 있습니다. 세 스레드를 거의 동시에 시작하면 어느 스레드가 먼저 println까지 가는지는 스케줄러가 정합니다.
RunnableStyleCatalog의 NamedTask는 value 필드를 쓰고 익명 클래스와 람다는 각각 짧은 print 본문을 전달합니다. 세 이름과 값의 짝은 고정이며 출력 순서는 보장하지 않습니다.
RUNNABLE · 세 표현
세 Runnable 표현은 같은 출력 형식을 만듭니다
클래스·익명 클래스·람다는 같은 이름=값 형식으로 출력합니다. 표현을 바꿔도 공유 상태 규칙은 같습니다.
이름 있는 클래스
- 실제 작업 본문의 구성
NamedTask의value필드run()이print(value)호출- 이름과 값의 출력
style-1=class
익명 클래스
- 실제 작업 본문의 구성
run()에서print("anonymous")호출- 이름과 값의 출력
style-2=anonymous
람다
- 실제 작업 본문의 구성
() -> print("lambda")- 이름과 값의 출력
style-3=lambda
세 줄의 순서는 고정하지 않습니다. 차이는 작업을 정의하는 위치와 상태 표현이며, 어느 문법도 가변 객체의 안전한 공유를 자동으로 보장하지 않습니다.
그림에서 보듯 세 문법의 차이는 작업을 어디에 정의하고 값을 어떻게 담느냐에 있습니다. NamedTask는 값을 필드에 담았고, 익명 클래스와 람다는 실행할 문장 안에 값을 직접 적었습니다. 그래도 세 경우 모두 결국 Runnable 객체 하나가 만들어져 Thread 생성자에 전달된다는 점은 같으므로, 문법을 바꾼다고 공유 문제가 생기거나 사라지지는 않습니다.
NamedTask에 static을 붙인 데도 이유가 있습니다. static이 없는 내부 클래스의 객체는 내부 클래스와 바깥 인스턴스에서 본 것처럼 자신을 만든 바깥 객체와 연결되고, 바깥 객체의 필드를 쓰면 그 필드를 다른 스레드와 함께 쓰게 됩니다. 정적 중첩 클래스는 바깥 객체와 연결되지 않으므로, 작업이 쓰는 값은 생성자로 받은 것뿐이라는 사실이 코드에 분명히 남습니다. value가 final이니 이 작업 객체는 어느 스레드가 언제 실행하든 바뀌지 않습니다.
익명 클래스는 필드를 가질 수 있다
익명 클래스는 람다와 달리 필드와 메서드를 여러 개 가질 수 있습니다. 다음 작업은 completed 필드로 처리한 단계 수를 세고, 출력은 record 메서드에 맡깁니다. 같은 작업 객체 task를 두 스레드에 차례로 넘겨 실행해 보겠습니다.
public final class AnonymousRunnableState {
public static void main(String[] args) throws InterruptedException {
Runnable task =
new Runnable() {
private int completed;
@Override
public void run() {
for (String stage : new String[] {"parse", "verify", "store"})
record(stage);
}
private void record(String stage) {
completed++;
System.out.println(
Thread.currentThread().getName() + " " + stage + " #" + completed);
}
};
Thread first = new Thread(task, "pipeline-1");
first.start();
first.join();
Thread second = new Thread(task, "pipeline-2");
second.start();
second.join();
}
}pipeline-2의 첫 줄에는 몇 번이 찍힐까요? 먼저 예상해 보세요.
결과 확인하기
pipeline-1 parse #1
pipeline-1 verify #2
pipeline-1 store #3
pipeline-2 parse #4
pipeline-2 verify #5
pipeline-2 store #6두 번째 스레드의 번호는 1이 아니라 4부터 시작합니다.
두 스레드가 실행한 것이 같은 익명 객체이고, completed는 그 객체의 필드이기 때문입니다. 스레드는 새로 만들었지만 작업 객체는 새로 만들지 않았으므로 상태가 그대로 이어집니다. 이 예제에서는 main이 first.join()으로 첫 스레드가 끝나기를 기다린 뒤에 두 번째 스레드를 시작했으므로, 두 스레드가 completed를 동시에 바꾸는 일이 없고 출력도 늘 같습니다. 두 스레드를 함께 실행하면 무슨 일이 생기는지는 뒤에서 따로 살펴봅니다. 실행할 때마다 독립된 상태가 필요하다면 스레드마다 작업 객체를 새로 만들면 됩니다.
람다는 바뀌는 지역 변수를 캡처할 수 없다
람다는 한두 문장짜리 작업을 그 자리에서 만들 때 가장 간결합니다. 대신 람다 본문에서 바깥 메서드의 지역 변수를 쓰려면 규칙 하나를 지켜야 합니다. 그 변수가 final이거나 사실상 final(effectively final), 즉 초기화한 뒤 다시 대입하지 않는 변수여야 합니다. 다음 코드는 람다가 쓰는 index를 뒤에서 index++로 바꾸므로 컴파일되지 않습니다.
public final class MutableLocalCaptureFailure {
public static void main(String[] args) {
int index = 0;
Runnable task = () -> System.out.println(index);
index++;
task.run();
}
}lab/MutableLocalCaptureFailure.java:4: error: local variables referenced from a lambda expression must be final or effectively final
Runnable task = () -> System.out.println(index);
^
1 error이 오류는 컴파일할 때 나므로 프로그램은 실행되지도 않습니다. index++를 람다보다 앞줄로 옮겨도 같은 오류가 납니다. 컴파일러는 대입이 람다보다 먼저인지 나중인지 따지지 않고, 그 변수가 한 번이라도 다시 대입되는지만 보기 때문입니다.
이런 규칙이 있는 이유는 람다가 지역 변수 자체가 아니라 그 값을 복사해서 가지고 다니기 때문입니다. 지역 변수는 메서드가 끝나면 사라지지만, 람다 객체는 다른 스레드에 넘겨져 메서드가 끝난 뒤에 실행될 수도 있습니다. 원래 변수가 계속 바뀔 수 있다면 복사해 둔 값과 원래 변수가 서로 달라져, 람다가 어느 쪽 값을 보는지 헷갈리게 됩니다. 자세한 배경은 지역 클래스와 변수 캡처에서 다뤘습니다.
반복문에서 회차마다 값을 고정하기
이 규칙은 반복문에서 스레드를 여러 개 만들 때 자주 부딪힙니다. for (int index = 0; ...; index++)의 index는 매 회차 다시 대입되므로 람다에서 바로 쓸 수 없습니다. 해결책은 반복문 본문 안에 새 지역 변수를 선언하고 그 회차의 값을 담는 것입니다. 본문 안에서 선언한 변수는 회차마다 새로 만들어지는 별개의 변수이고, 어느 회차에서도 다시 대입되지 않으므로 사실상 final입니다.
import java.util.ArrayList;
import java.util.List;
public final class LambdaTaskBatch {
public static void main(String[] args) throws InterruptedException {
List<String> actions = List.of("publish", "index", "notify");
List<Thread> workers = new ArrayList<>();
for (int index = 0; index < actions.size(); index++) {
String action = actions.get(index);
int number = index + 1;
Runnable task =
() ->
System.out.println(
Thread.currentThread().getName()
+ " action="
+ action
+ ", number="
+ number);
workers.add(new Thread(task, "lambda-" + number));
}
for (Thread worker : workers) {
worker.start();
}
for (Thread worker : workers) {
worker.join();
}
}
}lambda-3 action=notify, number=3
lambda-1 action=publish, number=1
lambda-2 action=index, number=2action과 number가 바로 그런 변수입니다. 첫 회차의 람다는 "publish"와 1을, 두 번째 회차의 람다는 "index"와 2를 캡처하고, 반복 변수 index 자체는 어느 람다도 캡처하지 않습니다. 줄의 순서는 실행마다 달라지지만 lambda-1에는 늘 publish와 1이, lambda-3에는 늘 notify와 3이 짝지어 나옵니다.
실패 예제의 index는 뒤의 증가 연산 때문에 캡처할 수 없습니다. LambdaTaskBatch는 각 회차의 action과 number를 고정해 publish 1, index 2, notify 3의 짝을 출력합니다.
람다 캡처 · 고정된 바인딩
변경한 지역 변수는 거부되고 각 회차의 고정 바인딩은 유지됩니다
실패 예제의 index++는 컴파일 전에 거부됩니다. 성공한 반복은 action·number의 짝을 회차별로 고정합니다.
실패 예제의 index
- 지역 변수의 값·변경
index=0뒤에서index++- 컴파일 또는 출력 결과
- 사실상
final이 아니어서 컴파일 오류
작업 목록 · 1회차
- 지역 변수의 값·변경
action=publishnumber=1- 컴파일 또는 출력 결과
lambda-1 action=publish, number=1
작업 목록 · 2회차
- 지역 변수의 값·변경
action=indexnumber=2- 컴파일 또는 출력 결과
lambda-2 action=index, number=2
작업 목록 · 3회차
- 지역 변수의 값·변경
action=notifynumber=3- 컴파일 또는 출력 결과
lambda-3 action=notify, number=3
실패 예제에는 반복문이 없습니다. 성공한 세 회차는 LambdaTaskBatch의 서로 다른 지역 바인딩이며 출력 순서가 아닙니다. 캡처한 참조의 대상 객체가 복제되는 것도 아닙니다.
그림은 앞의 실패 예제와 이 예제의 세 회차를 함께 정리한 것입니다. 실패 예제의 index는 컴파일 단계에서 거부되고, 성공한 예제는 회차마다 고정된 action과 number를 각 스레드의 출력으로 이어 줍니다. 그림에 적힌 대로 캡처한 참조가 가리키는 객체가 복제되지는 않는데, 이 점은 다음 절에서 봅니다. 향상된 for문 for (String action : actions)의 action도 회차마다 새로 만들어지므로 따로 복사하지 않고 바로 람다에서 쓸 수 있습니다.
final 참조를 캡처해도 객체는 공유된다
캡처 규칙을 피하려고 값을 배열에 담는 경우가 있습니다. 배열 변수 자체는 다시 대입하지 않으니 컴파일은 통과합니다. 다음 예제는 배열의 0번 칸을 출력하는 람다를 만든 뒤, 스레드를 시작하기 전에 그 칸을 바꿉니다.
public final class CaptureReferenceBoundary {
public static void main(String[] args) throws InterruptedException {
final int[] box = {7};
Thread worker = new Thread(() -> System.out.println("captured=" + box[0]));
box[0] = 9;
worker.start();
worker.join();
}
}람다를 만들 때 box[0]은 7이었습니다. 출력은 7일까요, 9일까요? 먼저 예상해 보세요.
결과 확인하기
captured=9람다가 복사해 둔 것은 box 변수에 들어 있던 참조, 즉 배열 객체가 어디 있는지에 대한 정보이지 그 순간의 배열 내용이 아니기 때문입니다. 람다 본문의 box[0]은 람다가 실행될 때 배열을 찾아가 읽으므로, 그사이 main이 바꾼 9를 읽습니다. final은 box에 다른 배열을 대입하지 못하게 할 뿐 배열 안의 칸이 바뀌는 것은 막지 않습니다. final 참조와 객체 변경에서 본 것과 같은 이야기입니다.
출력이 언제나 9인 것은 main이 box[0] = 9를 start() 전에 끝냈기 때문입니다. 프로세스와 스레드에서 본 것처럼 start()를 호출하기 전에 한 일은 새 스레드가 볼 수 있습니다. 반대로 스레드를 시작한 뒤에 main이 배열을 바꾸거나 여러 스레드가 같은 칸을 동시에 바꾼다면 이런 약속이 없습니다. 목록도 마찬가지여서, 람다가 목록을 캡처해 두었다가 실행할 때 원소를 꺼낸다면 그사이 다른 코드가 목록을 바꿀 수 있습니다. 이럴 때는 List.copyOf로 수정할 수 없는 복사본을 만들어 캡처합니다.
여기까지가 캡처의 규칙입니다. 람다는 바뀌지 않는 지역 변수의 값을 복사하고, 참조를 캡처하면 객체는 공유됩니다. 쉬어 가기 좋은 지점입니다.
작업 객체를 여러 스레드가 함께 쓰면
어떤 문법으로 만들든 Thread 생성자에 들어가는 것은 Runnable 객체 하나입니다. 그래서 스레드마다 새 작업 객체를 주는지, 하나를 여럿이 함께 쓰는지가 문법보다 훨씬 중요합니다. 다음 예제는 필드 count를 10만 번 늘리는 작업 객체 하나를 두 스레드에 함께 넘깁니다. 두 스레드가 10만 번씩 늘리니 결과는 200000이어야 할 것 같습니다.
public final class SharedCounterRace {
private static final class CountTask implements Runnable {
private int count;
@Override
public void run() {
for (int i = 0; i < 100_000; i++) {
count++;
}
}
}
public static void main(String[] args) throws InterruptedException {
CountTask task = new CountTask();
Thread a = new Thread(task, "counter-a");
Thread b = new Thread(task, "counter-b");
a.start();
b.start();
a.join();
b.join();
System.out.println("count=" + task.count);
}
}count=159936
count=200000
count=173318
count=177278
count=160065실행할 때마다 값이 다르고, 200000보다 작은 값이 자주 나옵니다. 가끔 200000이 나오기도 하지만 그렇다고 코드가 맞는 것은 아닙니다. 환경에 따라 200000이 여러 번 연달아 나온다면 반복 횟수를 100만 번으로 늘려 보세요. 두 스레드가 겹쳐 실행될 기회가 많아져 차이가 드러나기 쉽습니다.
값이 사라지는 이유는 count++가 한 번에 끝나는 동작이 아니기 때문입니다. 이 한 줄은 필드 값을 읽고, 1을 더하고, 그 결과를 필드에 쓰는 세 단계로 실행되며, 두 스레드의 단계가 사이사이 끼어들 수 있습니다. count가 41일 때 두 스레드가 거의 동시에 증가를 시작하면 다음과 같은 일이 생길 수 있습니다.
| 순서 | counter-a | counter-b | count |
|---|---|---|---|
| 1 | 41을 읽음 | 41 | |
| 2 | 41을 읽음 | 41 | |
| 3 | 42를 씀 | 42 | |
| 4 | 42를 씀 | 42 |
두 스레드가 한 번씩 늘렸는데 count는 1만 늘었습니다. counter-b가 counter-a의 결과를 보기 전에 옛 값 41을 읽어 버렸기 때문입니다. 이처럼 여러 스레드가 같은 값을 동시에 바꿔서 결과가 실행 순서에 따라 달라지는 상황을 경쟁 상태(race condition)라고 합니다. 람다로 캡처한 int[] 배열의 칸을 늘리게 하든, 익명 클래스의 필드를 늘리게 하든 문법과 상관없이 똑같이 일어납니다.
가장 간단한 해결책은 공유를 없애는 것입니다. CountTask는 그대로 두고 main만 다음처럼 바꾸면, 두 스레드가 각자의 객체만 바꾸고 main은 두 스레드가 끝난 뒤에 결과를 합칩니다.
public static void main(String[] args) throws InterruptedException {
CountTask taskA = new CountTask();
CountTask taskB = new CountTask();
Thread a = new Thread(taskA, "counter-a");
Thread b = new Thread(taskB, "counter-b");
a.start();
b.start();
a.join();
b.join();
System.out.println("count=" + (taskA.count + taskB.count));
}이렇게 바꾸면 몇 번을 실행해도 count=200000이 나옵니다. 각 count를 바꾸는 스레드가 하나뿐이고, main은 join()으로 두 스레드가 끝나기를 기다린 뒤에 값을 읽기 때문입니다. 하나의 값을 꼭 함께 바꿔야 한다면 락이나 AtomicInteger 같은 원자적 타입을 써야 하는데, 이것은 19장과 21장에서 배웁니다. 정리하면 여러 스레드가 함께 써도 되는 작업 객체는 필드가 없거나 NamedTask처럼 생성할 때 정한 불변 값만 가진 작업입니다. 실행하면서 바뀌는 상태를 가진 작업은 스레드마다 따로 만들거나, 동기화로 보호하거나, 큐처럼 값을 메시지로 주고받는 방식을 골라야 합니다. 장의 마지막 글의 프린터 서비스는 그중 큐를 씁니다.
어떤 문법을 고를까
| 상황 | 알맞은 문법 | 이유 |
|---|---|---|
| 여러 곳에서 다시 쓰고, 생성자로 값을 받고, 따로 테스트한다 | 이름 있는 클래스(정적 중첩 클래스나 최상위 클래스) | 필드가 작업이 가진 값을 보여 주고, 스택 트레이스에 이름이 남는다 |
| 한 곳에서만 쓰지만 필드나 도우미 메서드가 필요하다 | 익명 클래스 | 객체 구조를 쓰는 자리에서 바로 정의할 수 있다 |
| 한두 문장짜리 짧은 작업이고 바뀌는 상태가 없다 | 람다 | 가장 짧고, 캡처한 지역 변수가 바뀌지 않는다 |
어느 문법을 고르든 확인할 것은 같습니다. 작업이 어떤 값을 캡처하거나 필드로 가지고 있는지, 그리고 그 작업 객체와 그것이 가리키는 객체를 여러 스레드가 함께 쓰는지입니다.
더 깊이: 스택 트레이스에 남는 이름과 this
세 작업이 실행될 때 호출 스택에 남는 이름은 다릅니다. print에서 new Throwable().getStackTrace()[1]로 자신을 호출한 메서드를 찍어 보면, OpenJDK의 javac로 컴파일하면 대개 RunnableStyleCatalog$NamedTask.run, RunnableStyleCatalog$1.run, RunnableStyleCatalog.lambda$main$0이 나옵니다. 이름 있는 클래스는 소스에 쓴 이름이 그대로 남지만, 익명 클래스의 $1과 람다 메서드의 이름은 컴파일러가 정하므로 컴파일러나 코드 위치가 바뀌면 달라질 수 있습니다. 람다나 익명 클래스가 많아지면 로그만 보고 어느 작업인지 알아보기 어려워지는 이유입니다.
익명 클래스와 람다는 this가 가리키는 대상도 다릅니다. 인스턴스 메서드 안에서 만든 익명 Runnable의 this는 그 익명 객체 자신이고, 같은 자리에서 만든 람다의 this는 람다를 감싼 바깥 객체입니다. 람다는 새로운 this를 만들지 않기 때문입니다(JLS 15.27.2). 그래서 익명 클래스 안에서 자기 필드를 this로 쓰던 코드를 람다로 옮기면 같은 글자가 바깥 객체의 필드를 가리키게 됩니다.
정리
Runnable은 함수형 인터페이스여서 이름 있는 클래스, 익명 클래스, 람다로 모두 만들 수 있습니다. 어느 문법이든 결과는Thread에 넘길Runnable객체 하나입니다.- 익명 클래스는 필드를 가질 수 있고, 같은 익명 객체를 여러 스레드에 넘기면 그 필드도 함께 씁니다.
- 람다가 캡처하는 지역 변수는
final이거나 사실상final이어야 합니다. 반복문에서는 본문 안에 새 지역 변수를 선언해 회차마다 값을 고정합니다. final배열이나 목록을 캡처하면 참조만 복사되고 객체는 공유됩니다.start()전에 끝낸 변경은 새 스레드가 볼 수 있지만, 시작한 뒤의 동시 변경에는 동기화가 필요합니다.- 바뀌는 필드를 가진 작업 객체 하나를 여러 스레드에 넘기면 경쟁 상태가 생깁니다. 스레드마다 작업 객체를 따로 만들고
join()뒤에 합칩니다.
연습 문제
1. 같은 배열을 캡처한 세 람다
다음 프로그램은 배열 하나를 세 람다가 함께 캡처합니다. 람다를 만드는 동안 box[0]을 1, 2, 3으로 차례로 바꾸고, 모든 변경이 끝난 뒤에 세 스레드를 시작합니다. 출력을 예상하세요.
public final class SharedBoxQuestion {
public static void main(String[] args) throws InterruptedException {
final int[] box = {0};
Thread[] workers = new Thread[3];
for (int i = 0; i < workers.length; i++) {
box[0] = i + 1;
workers[i] = new Thread(() -> System.out.println("box=" + box[0]));
}
for (Thread worker : workers) worker.start();
for (Thread worker : workers) worker.join();
}
}해설 보기
세 줄 모두 box=3입니다. 세 람다가 캡처한 것은 같은 배열을 가리키는 참조 하나이고, box[0]은 람다가 실행될 때 읽습니다. 스레드가 실행될 때는 이미 마지막 대입 box[0] = 3이 끝난 뒤이고, 모든 대입을 start() 전에 마쳤으므로 세 스레드 모두 3을 봅니다.
2. 만들 때의 값을 출력하도록 고치기
1번 프로그램이 captured=1, captured=2, captured=3을 한 번씩 출력하도록 반복문 본문을 고치세요. 배열 box와 대입 box[0] = i + 1;은 그대로 둡니다. 고친 뒤에 각 스레드가 box[0]++까지 한 번씩 실행하게 하면 box[0]이 정확히 3만큼 늘어난다고 말할 수 있는지도 답하세요.
힌트
람다가 배열을 캡처하는 대신, 그 회차의 값을 담은 새 지역 변수를 캡처하게 합니다.
해설 보기
box[0] = i + 1;
int captured = box[0];
workers[i] = new Thread(() -> System.out.println("captured=" + captured));captured는 회차마다 새로 만들어지고 다시 대입되지 않으므로 각 람다가 그 회차의 값을 복사해 가집니다. 세 줄의 순서는 실행마다 달라질 수 있지만 1, 2, 3이 한 번씩 나옵니다.
box[0]++는 정확히 3만큼 늘어난다고 말할 수 없습니다. final은 box에 다른 배열을 대입하지 못하게 할 뿐이고, box[0]++도 count++처럼 읽기, 더하기, 쓰기의 세 단계라서 두 스레드가 같은 옛 값을 읽으면 증가 하나가 사라질 수 있습니다. 세 번뿐이라 겹칠 확률은 낮지만, 낮다는 것과 일어나지 않는다는 것은 다릅니다.
3. 문서마다 스레드 하나씩 출력하기
문서 이름 alpha, beta, gamma, delta를 각각 별도의 스레드에서 순번:값 형식으로 출력하는 SafeLoopCaptureSolution을 작성하세요. 문서 목록을 받아 작업자에게 넘기는 이 모양은 장의 마지막 글에서 프린터 서비스에 문서를 제출할 때 다시 나옵니다.
- 스레드 이름은
capture-0부터capture-3까지입니다. - 순번과 값의 짝이 맞아야 합니다(
0:alpha,1:beta, …). main은 모든 스레드가 끝나기를 기다린 뒤 마지막 줄에captured=4를 출력합니다.
힌트
반복문의 i는 람다에서 바로 쓸 수 없으므로 회차마다 slot과 value라는 새 지역 변수에 복사합니다. 시작한 스레드는 배열에 담아 두었다가 모두 join()합니다.
해설 보기
public final class SafeLoopCaptureSolution {
public static void main(String[] args) throws InterruptedException {
String[] values = {"alpha", "beta", "gamma", "delta"};
Thread[] workers = new Thread[values.length];
for (int i = 0; i < values.length; i++) {
int slot = i;
String value = values[i];
workers[i] =
new Thread(() -> System.out.println(slot + ":" + value), "capture-" + slot);
workers[i].start();
}
for (Thread worker : workers) {
worker.join();
}
System.out.println("captured=" + workers.length);
}
}3:delta
0:alpha
1:beta
2:gamma
captured=4javac -d out src/SafeLoopCaptureSolution.java와 java -cp out SafeLoopCaptureSolution으로 확인합니다. 앞의 네 줄은 실행마다 순서가 바뀌지만, 순번과 값의 짝은 언제나 맞고 네 짝이 한 번씩 나타납니다. 마지막 줄 captured=4는 main이 네 스레드를 모두 join()한 뒤에 출력하므로 항상 맨 끝에 나옵니다.
다음 글
스레드 정보와 생명 주기에서는 스레드의 ID, 이름, 우선순위 같은 정보를 조회하고, 스레드가 NEW에서 TERMINATED까지 어떤 상태를 거치는지 직접 만들어 확인합니다.