🐹 8. Thread & Lock

15. 스레드와 락

[ 자바의 스레드 ]

자바의 모든 스레드는 java.lang.Thread 클래스 객체에 의해 생성되고 제어된다.

독립적인 응용 프로그램이 실행될 때, main() 메서드를 실행하기 위한 하나의 사용자 스레드(user thread)가 자동으로 만들어 지는데, 이 스레드를 주 스레드(main thread)라고 부른다.

자바에서 스레드를 구현하는 방법 두 가지는 다음과 같다.

• java.lang.Runnable 인터페이스를 구현하기
• java.lang.Thread 인터페이스를 구현하기

Runnable 인터페이스를 구현하는 방법

Runnable 인터페이스는 단순한 구조를 가진다.

public interface Runnable {
    void run();
}

이 인터페이스를 사용해 스레드를 만들고 사용하려면 다음의 과정을 거쳐야 한다.

1. Runnable 인터페이스를 구현하는 클래스를 만든다. 이 클래스의 객체는 Runnable 객체가 된다.

2. Thread 타입의 객체를 만들 때, Thread의 생성자에 Runnable 객체를 인자로 넘긴다.

   이 Thread 객체는 이제 run() 메서드를 구현하는 Runnable 객체를 소유하게 된다.

3. 이전 단계에서 생성한 Thread 객체의 start() 메서드를 호출한다.

// 1번 수행(Runnable 인터페이스 구현)
public class RunnableThreadExample implements Runnable {
    public int count = 0;

    public void run() {
        System.out.println("RunnableThread starting");
        try {
            while (count < 5) {
                Thread.sleep(500);
                count++;
            }
        } catch (InterruptedExceptiono exc) {
            System.out.println("RunnableThread interrupted.");
        }
        System.out.println("RunnableThread terminating.");
    }
}

public static void main(String[] args) {
    RunnableThreadExample instance = new RunnableThreadExample();
    Thread thread = new Thread(instance);  // 2번 수행
    thread.start();  // 3번 수행		

    /* 스레드 개수가 5개가 될 때까지 천천히 기다린다. */
    while (instance.count != 5) {
        try {
            Thread.sleep(250);
        } catch (InterruptedException exc) {
            exc.printStackTrace();
        }
    }
}

위 코드에서 실제로 해야하는 일은 run() 메서드를 구현하는 것 뿐이다. 그러면 main 메서드는 해당 클래스의 인스턴스(instance)를 new Thread(obj)의 인자로 넘기고 start()를 호출한다.

Thread 클래스 상속

Runnable 이외에 Thread 클래스를 상속받아서 스레드를 만들 수도 있다. 그러려면 거의 항상 run() 메서드를 오버라이드(override)해야 하며, 하위 클래스의 생성자는 상위 클래스의 생성자를 명시적으로 호출해야 한다.

/* 스레드 상속 */
public class ThreadExample extends Thread {
    int count = 0;

    public void run() {
        System.out.println("Thread starting");
        try {
            while (count < 5) {
                Thread.sleep(500);
                System.out.println("In Thread, count is " + count);
                count++;
            }
        } catch (InterruptedException exc) {
            System.out.println("Thread interrupted.");
        }
        System.out.println("Thread terminating");
    }
}

public class ExampleB {
    public static void main(String args[]) {
        ThreadExample instance = new ThreadExample();
        instance.start();

        while (instance.count != 5) {
            try {
                Thread.sleep(250);
            } catch (InterruptedException exc) {
                exc.printStackTrace();
            }
        }
    }
}

Runnable 인터페이스 구현과 다른 점은 인터페이스를 구현하는 대신 Thread 클래스를 상속받았고, 따라서 인스턴스 자체에서 start()를 직접 호출하게 된다.

Thread 상속 vs Runnable 인터페이스 구현

스레드르 생성할 때 Runnable 인터페이스를 구현하는 것이 Thread를 상속받는 것보다 선호되는 이유가 두 가지 존재한다.

• 자바는 다중 상속(multiple inheritance)를 지원하지 않는다. 따라서 Thread 클래스를 상속하게 되면 하위 클래스는 다른 클래스를 상속할 수가 없다. 하지만 Runnable 인터페이스를 구현하는 클래스는 다른 클래스를 상속할 수 있다.
• Thread 클래스의 모든 것을 상속받는 것이 너무 부담되는 경우에는 Runnable을 구현하는 편이 나을지도 모른다.

[ 동기화와 락 ]

한 프로세스 안에서 생성된 스레드들은 같은 메모리 공간을 공유한다. 스레드가 서로 데이터를 공유할 수 있다는 점은 장점이긴 하지만 두 스레드가 같은 자원을 동시에 변경하는 경우에는 문제가 된다.

자바는 공유 자원에 대한 접근을 제어하기 위한 동기화(synchronization) 방법을 제공한다.

synchronized와 Lock이라는 키워드는 동기화 구현을 위한 기본이 된다.

동기화된 메서드

통상적으로 synchronized 키워드를 사용할 때는 공유 자원에 대한 접근을 제어한다.

이 키워드는 메서드에 적용할 수도 있고, 특정한 코드 블록에 적용할 수도 있다. 또한 여러 스레드가 같은 객체를 동시에 실행하는 것 또한 방지해주준다.

public class MyClass extends Thread {
    private String name;
    private MyObject myObj;

    public MyClass(MyObject obj, String n) {
        name = n;
        myObj = obj;
    }

    public void run() {
        myObj.foo(name);
    }
}

public class MyObject {
    public **synchronized** void foo(String name) {
        try {
            System.out.println("Thread" + name + ".foo(): starting");
            Thread.sleep(3000);
            System.out.println("Thread" + name + ".foo(): ending");
        } catch (InterruptedException exc) {
            System.out.println("Thread" + name + ": interrupted.");
        }
    }
}

두 개의 MyClass 인스턴스가 foo를 동시에 호출할 수 있을까? 상황에 따라 다르다.

같은 MyObject 인스턴스를 가리키고 있다면 동시 호출은 불가능하지만 다른 인스턴스를 가리키고 있다면 가능하다.

/* 서로 다른 객체인 경우 동시에 MyObject.foo() 호출이 가능하다. */
MyObject obj1 = new MyObject();
MyObject obj2 = new MyObject();
MyClass thread1 = new MyClass(obj1, "1");
MyClass thread2 = new MyClass(obj2, "2");
thread1.start();
thread2.start();

/* 같은 obj를 가리키고 있는 경우에는 하나만 foo를 호출할 수 있고, 
 * 다른 하나는 기다리고 있어야 한다. */
MyObject obj = new MyObject();
MyClass thread1 = new MyClass(obj, "1");
MyClass thread2 = new MyClass(obj, "2");
thread1.start();
thread2.start();

정적 메서드(static method)는 클래스 락(class lock)에 의해 동기화 된다. 같은 클래스에 있는 동기화된 정적 메서드는 두 스레드에서 동시에 실행될 수 없다. 설사 하나는 foo를 호출하고 다른 하나는 bar를 호출한다고 해도 말이다.

public class MyClass extends Thread {
    ...
    public void run() {
        if (name.equals("1")) MyObject.foo(name);
        else if (name.equals("2")) MyObject.bar(name);
    }
}

public class MyObject {
    public static synchronized void foo(String name) { /* ... */ }
    public static synchronized void bar(String name) { /* ... */ }
}

이 코드를 실행했을 때 출력되는 결과는 다음과 같다.

Thread 1.foo(): starting
Thread 1.foo(): ending
Thread 2.bar(): starting
Thread 2.bar(): ending

동기화된 블록

이와 비슷하게, 특정한 코드 블록을 동기화할 수도 있다. 이는 메서드를 동기화하는 것과 아주 비슷하게 동작한다.

public class MyClass extends Thread {
    ...
    public void run() {
        myObj.foo(name);
    }
}

public class MyObject {
    public void foo(String name) {
        **synchronized**(this) {
            ...
        }
    }
}

메서드를 동기화하는 것과 마찬가지로, MyObject 인스턴스 하나당 하나의 스레드 만이 synchronized 블록 안의 코드를 실행할 수 있다. 다시 말해 thread1과 thread2가 동일한 MyObject 인스턴스를 갖고 있다면, 그 가운데 하나만 그 코드 블록을 실행할 수 있다.

락

좀 더 세밀하게 동기화를 제어하고 싶을 떄는 락(lock)을 사용한다. 락(모니터(monitor)라고도 한다)을 공유 자원에 붙이면 해당 자원에 대한 접근을 동기화할 수 있다.

스레드가 해당 자원을 접근하려면 우선 그 자원에 붙어 있는 락을 획득해야 한다. 특정 시점에 락을 쥐고 있을 수 있는 스레드는 하나뿐이다. 따라서 해당 공유자원은 한 번에 한 스레드만이 사용할 수 있다.

어떤 자원이 프로그램 내의 이곳저곳에서 사용되지만 한 번에 한 스레드만 사용하도록 만들고자 할 때 주로 락을 이용한다.

public class LockedATM {
    private Lock lock;
    private int balance = 100;

    public LockedATM() {
        lock = new ReentrantLock();
    }

    public int withdraw(int value) {
        lock.lock();
        int temp = balance;
        try {
            Thread.sleep(100);
            temp = temp - value;
            Thread.sleep(100);
            balance = temp;
        } catch (InterruptedExceptino e) {
        lock.unlock();
        return temp;
    }

    public int deposit(int value) {
        lock.lock();
        int temp = balancee;
        try {
            Thread.sleep(100);
            temp = temp + value;
            Thread.sleep(300);
            balance = temp;
        } catch (InterruptedException e) { }
        lock.unlock();
        return temp;
    }
}

락을 사용하면 공유된 자원이 예기치 않게 변경되는 일을 막을 수 있다.

(Thread.sleep은 발생 가능한 문제점을 보이기 위해 일부러 느리게 만든것 - 사용 안해도됨)

[ 교착상태와 교착상태 방지 ]

교착상태(deadlock)

첫 번째 스레드는 두 번째 스레드가 들고 있는 객체의 락이 풀리기를 기다리고 있고, 두 번째 스레드 역시 첫 번째 스레드가 들고 있는 객체의 락이 풀리기를 기다리는 상황(여러 스레드가 관계되어 있을 때 발생할 수 있다.)

모든 스레드가 락이 풀리기를 기다리고 있기 때문에, 무한 대기 상태에 빠지게 된다.

교착 상태가 발생하려면, 다음의 네 가지 조건이 모두 충족되어야 한다.

• 상호 배제(mutual exclusion)

  : 한 번에 한 프로세스만 공유 자원을 사용할 수 있다.(좀 더 정확히 이야기하자면, 공유 자원에 대한 접근 권한이 제한된다. 자우너의 양이 제한되어 있더라도(한 개 이상) 교착상태는 발생할 수 있다.)

• 들고 기다리기(hold and wait)

  : 공유 자원에 대한 접근 권한을 갖고 있는 프로세스가, 그 접근 권한을 양보하지 않은 상태에서 다른 자원에 대한 접근 권한을 요구할 수 있다.

• 선취(preemption) 불가능

  : 한 프로세스가 다른 프로세스의 자원 접근 권한을 강제로 취소할 수 없다.

• 대기 상태의 사이클(circular wait)

  : 두 개 이상의 프로세스가 자원 접근을 기다리는데, 그 관계에 사이클(cycle)이 존재한다.

교착 상태를 방지하기 위해선 위 조건들 중 하나를 제거하면 된다. 하지만 이들 조건 가운데 상당수는 만족되기 어려운 것이라 까다롭니다.

공유 자원 중 많은 경우가 한 번에 한 프로세스만 사용할 수 있기 때문에(ex. 프린터) 1번 조건은 제거하기 어렵다. 대부분의 교착상태 방지 알고리즘은 4번 조건, 즉 대기 상태의 사이클이 발생하는 일을 막는 데 초점이 맞춰져 있다.