하나의 프로세스가 두 가지 이상의 작업을 처리할 수 있는 이유는 멀티 스레드가 있기 때문이다.
프로세스의 모든 스레드가 종료가 되어야 프로세스가 종료된다.
하나의 스레드에서 예외가 발생하면 모든 스레드가 종료되어 결국 프로세스도 종료되므로 예외 처리에 만전을 기해야 한다.
메인 스레드 모든 자바 프로그램은 메인 스레드가 main() 메소드를 실행하면서 시작된다. 메인 스레드는 main() 메소드의 첫 코드부터 순차적으로 실행하고, main() 메소드의 마지막 코드를 실행하거나 return문을 만나면 실행을 종료한다.
메인 스레드는 필요에 따라 추가 작업 스레드들을 만들어서 실행시킬 수 있다. 멀티 스레드에서는 실행 중인 스레드가 하나라도 있다면 프로세스는 종료되지 않는다. 즉, 메인 스레드가 작업 스레드보다 먼저 종료되더라도 작업 스레드가 하나라도 실행 중이라면 프로세스는 종료되지 않는다.
한 프로세스에 하나의 JVM이 실행된다. 여러 자바 프로세스가 실행중이라면 여러 JVM이 있는 것이다.
작업 스레드 생성과 실행
멀티 스레드로 실행하는 프로그램을 개발하려면 먼저 몇 개의 작업을 병렬로 실행할지 결정하고 각 작업별로 스레드를 생성해야한다.
중요한 점은 아래의 방법 중에 어떤 방법을 사용해서 생성을 하든 상관이 없지만, 작업 스레드를 실행하려면 스레드 객체의 start() 메소드를 호출해야 한다.
Runnable 구현 객체를 만들어서 생성
Runnable 구현 클래스 작성
작업 스레드 객체를 직접 생성하려면, java.lang 패키지에 있는 Thread 클래스로부터 작업 스레드 객체를 생성하면 된다.
객체를 생성할 때에는 Runnable 구현 객체를 매개값으로 갖는 생성자를 호출해야 한다.
Runnable 인터페이스 스레드가 작업을 실행할 때 사용하는 인터페이스이다. Runnable에는 run() 메소드가 정의되어 있는데, 구현 클래스는 run()을 오버라이딩해서 스레드가 실행할 코드를 가지고 있어야 한다.
Runnable 구현 클래스는 작업 내용을 정의한 것이므로, 스레드에게 전달해야 한다.
Runnable 구현 객체를 생성한 후 Thread 생성자 매개값으로 Runnable 객체를 전달하면 된다.
start() 메소드가 호출되면, 작업 스레드는 매개값으로 받은 Runnable의 run() 메소드를 실행하면서 작업을 처리한다.
다음은 작업 스레드가 생성되고 실행되기까지의 순서를 보여준다.
public class Task implements Runnable{
@Override
public void run() {
//실행할 코드 작성
}
}
public class Main {
public static void main(String[] args) {
Runnable task = new Task();
Task task2 = new Task();
Thread thread = new Thread(task);
Thread thread2 = new Thread(task2);
thread.start();
thread2.start();
}
}
Runnable 익명 구현 객체로 생성
아래와 같이 익명 구현 객체를 생성하여 매개값으로 사용할 수도 있다.
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() { //익명 구현 객체
@Override
public void run() {
//실행할 코드 작성
}
});
thread.start();
}
}
Thread 자식 클래스로 생성
명시적인 자식 클래스 정의 후 생성
작업 스레드 객체를 생성하는 또 다른 방법은 Thread의 자식 객체로 만드는 것이다.
Thread 클래스를 상속한 다음 run() 메소드를 오버라이딩해서 스레드가 실행할 코드를 작성하고 객체를 생성하면 된다.
작업 스레드를 실행하는 방법은 동일하다.
start() 메서드를 호출하면 작업 스레드는 재정의된 run()을 실행시킨다.
public class Task extends Thread{
@Override
public void run() {
//실행할 코드 작성
}
}
public class Main {
public static void main(String[] args) {
//방법1
Thread thread = new Thread(new Task());
thread.start();
//방법2
Task task = new Task();
Thread thread2 = new Thread(task);
thread2.start();
//방법3
Task task2 = new Task();
task2.start();
}
}
Thread 익명 자식 객체로 생성
명시적인 자식 클래스를 정의하지 않고, 아래와 같이 Thread 익명 자식 객체를 사용할 수도 있다.
public class Main {
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
//실행할 코드 작성
}
};
thread.start();
}
}
스레드 이름
메인 스레드는 main이라는 이름을 가진다.
작업 스레드는 자동적으로 Thread-n이라는 이름을 가진다.
다른 이름으로 설정하고 싶다면 Thread 클래스의 setName() 메소드를 사용하면 된다.
당연히 스레드를 실행하기 전에 스레드 이름을 바꿔야 한다.
thread.setName("스레드 이름");
어떤 스레드가 실행하고 있는지 확인하려면 정적 메소드인 CurrentThread()로 스레드 객체의 참조를 얻은 다음 getName() 메소드로 스레드의 이름을 얻고 출력해 보면 된다.
- 다음 예제에서는 처음 5초 동안은 ThreadA와 ThreadB가 번갈아 가며 실행하다가 5초 뒤에 메인 스레드가 ThreadA의 work 필드를 false로 변경함으로써 ThreadA가 yield() 메소드를 호출한다.
- 따라서 ThreadB가 더 많은 실행 기회를 얻게 된다.
- 그리고 10초 뒤에 ThreadA의 work 필드를 true로 변경해 ThreadA와 ThreadB가 다시 번갈아 가며 실행된다.
WorkThread.java
public class WorkThread extends Thread {
//필드
public boolean work = false;
//생성자
public WorkThread(String name) {
setName(name);
}
//메소드
@Override
public void run() {
while(true) {
if(work) {
System.out.println(getName() + ": 작업처리");
} else {
Thread.yield();
}
}
}
}
YieldExample.java
public class YieldExample {
public static void main(String[] args) {
WorkThread workThreadA = new WorkThread("workThreadA");
WorkThread workThreadB = new WorkThread("workThreadB");
workThreadA.start();
workThreadB.start();
try { Thread.sleep(5000); } catch (InterruptedException e) {}
workThreadA.work = false;
try { Thread.sleep(10000); } catch (InterruptedException e) {}
workThreadA.work = true;
}
}
스레드 동기화
멀티 스레드는 하나의 객체를 공유해서 작업할 수도 있다.
이 경우, 다른 스레드에 의해 객체 내부 데이터가 쉽게 변경될 수 있기 때문에 의도했던 것과는 다른 결과가 나올 수 있다.
User1Thread는 Calculator 객체의 memory 필드에 100을 먼저 저장하고 2초간 일시 정지 상태가 된다.
그동안 User2Thread가 memory 필드값을 50으로 변경한다.
2초가 지나 User1Thread가 다시 실행 상태가 되어 memory 필드의 값을 출력하면 User2Thread가 저장한 50이 나온다.
동기화 메소드와 블록
스레드 A가 공유 자원(객체)을 사용 중인데 다른 스레드인 스레드 B가 접근하려고 하면 스레드 A가 사용 중인 객체를 다른 스레드가 변경할 수 없도록 하려면 스레드 작업이 끝날 때까지 객체에 잠금을 걸면 된다.
이를 위해 자바는 동기화 메소드와 블록을 제공한다.
공유 객체의 동기화 메소드는 하나의 스레드만 사용할 수 있다.(객체 잠금)
공유 객체의 동기화 블록은 하나의 스레드만 사용할 수 있다.(객체 잠금)
공유 객체의 일반 메소드는 모든 스레드가 사용할 수 있다.
동기화 메소드는 다음과 같이 synchronized 키워드를 붙이면 된다.
synchronized 키워드는 인스턴스와 정적 메소드 어디든 붙일 수 있다.
스레드가 동기화 메소드를 실행하는 즉시 객체는 잠금이 일어나고, 메소드 실행이 끝나면 잠금이 풀린다.
메소드 전체가 아닌 일부 영역을 실행할 때만 객체 잠금을 걸고 싶다면 다음과 같이 동기화 블록을 만들면 된다.
public void method(){
//여러 스레드가 실행할 수 있는 영역
synchronized(공유 객체){
//단 하나의 스레드만 실행하는 영역
}
//여러 스레드가 실행할 수 있는 영역
}
동기화 메서드와 동기화 블록은 모니터(lock)라는 개념으로 스레드 간의 동기화를 보장한다.
같은 모니터를 사용하는 동기화 영역은 한 번에 하나의 스레드만 실행할 수 있다. 예를 들어, 하나의 객체 내에서 일반 동기화 메서드들은 객체 자신(this)을 모니터로 사용하므로 동시에 실행될 수 없고, 정적 동기화 메서드들은 클래스 객체를 모니터로 사용하므로 역시 동시에 실행될 수 없으며, 동기화 블록도 같은 모니터 객체를 사용한다면 동시에 실행될 수 없다.
단, 서로 다른 모니터를 사용하는 동기화 영역들은 동시에 실행이 가능하다.
동기화 메서드 1과 2가 같은 객체에서 실행된다면, 하나가 실행 중일 때 다른 하나는 절대 동시에 실행되지 않는다.
왜냐하면 둘 다 같은 객체에 락을 걸기 때문이다.
예를 들어, A객체에 동기화 메서드1()이 실행 중이라면, 다른 스레드가 같은 A객체의 동기화 메서드2()를 호출하더라도 락이 풀릴 때까지 기다려야 한다. 동기화 블록도 마찬가지로, synchronized(this)처럼 같은 객체를 락 걸면 메서드든 블록이든 서로 대기하게 되고, 반대로 synchronized(별도 객체)처럼 다른 객체를 락 걸면 동시에 실행될 수 있다. 핵심은 "어떤 객체를 기준으로 락을 거느냐"이다.
아래의 예제는 공유 객체인 WorkObject에 동기화 메소드인 ThreadA와 ThreadB가 각 methodA와 methodB를 호출한다.
WorkObject.java
public class WorkObject {
public synchronized void methodA() {
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + ": methodA 작업 실행");
notify();
try {
wait();
} catch (InterruptedException e) {
}
}
public synchronized void methodB() {
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + ": methodB 작업 실행");
notify();
try {
wait();
} catch (InterruptedException e) {
}
}
}
ThreadA.java
public class ThreadA extends Thread {
private WorkObject workObject;
public ThreadA(WorkObject workObject) {
setName("ThreadA");
this.workObject = workObject;
}
@Override
public void run() {
for(int i=0; i<10; i++) {
workObject.methodA();
}
}
}
ThreadB.java
public class ThreadB extends Thread {
private WorkObject workObject;
public ThreadB(WorkObject workObject) {
setName("ThreadB");
this.workObject = workObject;
}
@Override
public void run() {
for(int i=0; i<10; i++) {
workObject.methodB();
}
}
}
WaitNotifyExample.java
public class WaitNotifyExample {
public static void main(String[] args) {
WorkObject workObject = new WorkObject();
ThreadA threadA = new ThreadA(workObject);
ThreadB threadB = new ThreadB(workObject);
threadA.start();
threadB.start();
}
}
/*
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
ThreadA: methodA 작업 실행
ThreadB: methodB 작업 실행
*/
스레드 안전 종료
스레드는 자신의 run() 메소드가 모두 실행되면 자동적으로 종료되지만, 경우에 따라서는 실행 중인 스레드를 즉시 종료할 필요가 있다.
스레드를 강제 종료시키기 위해 Thread는 stop() 메소드를 제공하고 있으나 이 메소드는 사용하지 않는 것을 추천한다.
스레드를 갑자기 종료하게 되면 사용 중이던 리소스들이 불안전한 상태로 남겨지기 때문이다.
스레드를 안전하게 종료하는 방법은 리소스들을 정리하고 run() 메소드를 빨리 종료하는 것이다.
이를 위해 아래의 두 가지 방법을 사용한다.
조건 이용
interrupt() 메소드 이용
조건 이용
스레드가 while 문으로 반복 실행할 경우, 조건을 이용해서 run() 메소드의 종료를 유도한다.
public class XXXThread extends Thread {
private boolean stop;
public void setStop(boolean stop) {
this.stop = stop;
}
@Override
public void run() {
while(!stop) {
System.out.println("실행 중");
}
System.out.println("리소스 정리");
System.out.println("실행 종료");
}
}
interrupt() 메소드 이용
일시 정지를 이용한 방법
interrupt() 메소드는 스레드가 일시 정지 상태에 있을 때 InterruptedException 예외를 발생시키는 역할을 한다.
이것을 이용하면 예외 처리를 통해 run() 메소드를 정상 종료시킬 수 있다.
즉, 이 방법은 스레드가 일시 정지 상태에 있을 때만 가능하다.
일시 정지 상태일 때 처리하는 InterruptedException 예외 처리를 이용한 방법이기 때문이다.
public class PrintThread extends Thread {
public void run() {
try {
while(true) {
System.out.println("실행 중");
Thread.sleep(1);
}
} catch(InterruptedException e) {
}
System.out.println("리소스 정리");
System.out.println("실행 종료");
}
}
InterruptExample.java
public class InterruptExample {
public static void main(String[] args) {
Thread thread = new PrintThread();
thread.start();
try {
Thread.sleep(100); //메인 스레드를 일시정지. 작업 스레드를 멈추는게 아님
} catch (InterruptedException e) {
}
thread.interrupt(); //작업 스레드 인터럽트
}
}
/*
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
리소스 정리
실행 종료
*/
일시 정지를 이용하지 않는 방법
Thread의 interrupted()와 isInterrupt() 메소드는 interrupt() 메소드 호출 여부를 리턴한다.
interrupted() : 정적 메소드 -> 객체 생성 없이 사용 가능
isInterrupt() : 인스턴스 메소드 -> 객체를 생성해야 사용 가능
이 방법은 위 메소드를 이용하여 interrupt() 메소드 호출 여부를 확인하고 호출되었다면, while 블록을 빠져나가 리소스 정리를 하고 스레드를 종료하게끔 유도한다.
public class PrintThread extends Thread{
public void run() {
while(true){
System.out.println("실행 중");
if(Thread.interrupted()) { //interrupt() 메소드가 호출되었는지 확인
break; //interrupt() 메소드가 호출되었다면 while문 탈출
}
}
System.out.println("리소스 정리");
System.out.println("실행 종료");
}
}
Main.java
public class Main {
public static void main(String[] args) {
Thread thread = new PrintThread();
thread.start();
try {
Thread.sleep(1); //메인 스레드를 일시정지, 작업 스레드를 일시 정지 하는것이 아님
}catch (InterruptedException e) {
}
thread.interrupt(); //작업 스레드 인터럽트
}
}
/*
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
리소스 정리
실행 종료
*/