Java Thread 개념

Series

Thread란?

Main Thread

• Java 프로그래밍을 실행하면 하나의 스레드가 즉시 실행되기 시작합니다. 즉 시작과 동시에 Thread가 기반에 실행됩니다. 그래서 일반적으로 프로그램의 Main Thread라고 합니다.

• 다른 자식 스레드가 생성되는 스레드입니다.

• 다양한 종류 작업을 수행하기 때문에 실행을 완료하는 마지막 스레드입니다.

• Main Thread는 프로그램 시작될 때 자동으로 생성됩니다.

• 생성된 쓰레드를 제어하기 위해서 current thread() 메서 들을 호출하면 해당 Thread의 참조를 얻을수 있습니다.

Single Thread

• Main 스레드에서 작업 진행, 작업을 순차적으로 진행됨

• 하나의 프로세스에서 오직 하나의 스레드로만 진행

• 단일 레지스터와 스택으로 구성

• Context Switching 작업을 요구하지 않음

• 동시성 제어에 대한 처리를 신경 쓰지 않아도 됨

Single Thread 장점

• 자원 접근에 대한 동기화를 고려하지 않아도 됩니다. ** 여러 개의 스레드가 프로세스의 자원을 공유하면, 각 스레드가 자원 접근에 대해서 접근제어를 해야 합니다. ** 모든 스레드가 자원에 동시에 접근하거나, 동일한 작업을 실행하면 Exception이 발생합니다. ** Single Thread 환경에서는 동기화에 대해서 고려할 필요가 없습니다.

• Context switch(문맥 교환) 작업을 요구하지 않습니다. ** 현재 진행하고 있는 Task(Process,Thread)의 상태를 저장하고 다음 진행할 Task의 상태 값을 읽어 적용하는 과정을 말합니다. ** Multi-Thread 환경에서는 Context switching을 통해서 실시간처럼 보이게 처리합니다. ** Single Thread에서는 Context switching 필요하지 않음으로 Context switching에 대한 비용이 발생하지 않습니다.

• 단순히 계산 작업이라면 Multi-Thread보다 Single-Thread 기반으로 개발하는 것이 더 효율적입니다. ** 간단한 계산이라면 Multi-thread 환경에서 작업을 하면 context-switching 발생으로 Single-thread에서 오히려 시간이 더 발생할 수 있습니다.

• 개발 난이도가 쉽고, CPU, Memory를 적게 사용합니다. ( 사용 비용을 줄일 수 있습니다.)

Single Thread 단점

• Multi CPU를 활용하지 못합니다.

• 연산량이 많은 작업의 경우 그 작업이 완료되어야 다음 작업을 진행할 수 있습니다.

• 싱글 스레드는 Error 처리를 못 하는 경우 중지됩니다.

Multi Thread

• 프로그램 내에서 두 개 이상의 동작을 동시에 실행 ** CPU의 활동을 극대화 ** 두 개가 동작을 동시에 실행

• 하나의 프로세스를 다수의 실행 단위로 구분하여 자원을 공유 ** 자원의 생성과 관리의 중복성 최소화 ** 수행 능력 향상

Multi Thread 장점

• 프로그램 일부분이 중단이 되거나 긴 작업을 수행하더라도 프로그램 수행이 지속적으로 유지되어 사용자에 대한 응답성이 증가합니다.

• Multi Thread 환경에서는 에러 발생 시 새로운 Thread를 생성해서 error를 극복합니다.

• 프로세스 내 자원들과 메모리를 공유하기 때문에 메모리 자원과 시스템 공간을 효율적으로 활용할 수 있습니다.

• 스레드 간 통신에서도 데이터를 주고받을 수 있으며, 프로세스 간의 Context switching과는 달리 스레드 간의 context switching은 캐시 메모리를 비울 필요가 없기 때문에 더 빠르게 동작 합니다.

• 멀티프로세서의 활용 ** Multi Core CPU 환경에서는 각각의 스레드가 다른 프로세서에서 병렬로 수행될 수 있으므로 병렬성이 증가합니다.

Multi Thread 단점

• Context switching, 동기화 등의 이유로 싱글 코어 멀티 스레딩은 스레드 생성 시간이 오히려 오버헤드로 작용해 단일 스레드보다 느릴 수 있습니다.

• 공유자원을 서로 다른 스레드가 동시에 접근하는 경우, 스레드 내에서는 Heep 영역을 공유하기 때문에 다른 스레드에서 사용 중인 변수나 자료구조에 접근하여 엉뚱한 값을 읽어오거나 수정할 수 있습니다.

• 그래서 반드시 동기화 처리를 해야 합니다. 즉 동기화 비용이 발생합니다.

• 멀티 스레드 환경은 개발 난도가 높습니다. 또한 자원 사용량도 많습니다.

Thread Life Cycle

Thread 상태

New

• 스레드가 실행 준비를 완료한 상태(Thread 객체가 생성된 상태)로, start() 메소드를 호출하기 전 상태

Runnable

• start()가 호출되어 실행될 수 있는 상태

• 스레드 스케줄링에 따라 CPU에서 실행될 기회를 기다리는 상태

Wait

• 다른 스레드가 통지할 때까지 기다리는 상태

Timed_wait

• 정해진 시간 동안 기다리는 상태

• Thread.sleep(1000) <- 1초 대기

Blocked

• 사용하고자 하는 객체의 잠금(lock)이 풀릴 때까지 대기하는 상태

Terminated

• 실행이 종료된 상태

Thread 상태변경 method

• interrupt()
• 스레드에서 InterruptedException 예외를 발생시켜 예외 처리 코드에서 실행 대기 상태로 가거나 종료 상태로 가도록 함

• notify()
• Block 상태에서 wait() 메소드에 의해 Wait 상태에 있는 스레드를 Runnable 상태로 만듦

• sleep()
• 주어진 시간 동안 스레드를 Timed_wait 상태로 만듦. 주어진 시간이 지나면 자동으로 Runnable 상태로 바뀜

• join()
• join()을 사용하면 메인 스레드가 다른 스레드들이 종료될 때까지 기다리게 되어, 스레드 간의 순서를 조절하고 동기화할 수 있습니다.

• wait()
• Block에서 스레드를 Wait 상태로 만듦. 파라미터로 주어진 시간이 지나면 Runnable 상태가 됨. 시간이 주어지지 않은 경우 notify(), notifyAll() 메소드에 의해 Runnable 상태로 변경됩니다.

• yeild()
• 실행 중에 우선순위가 동일하거나 높은 순위의 스레드를 산출하고 Wait 상태로 변경합니다

동기화 매커니즘

Synchronized

• method 동기화
메서드 단위에서 하나의 스레드만 접근할 수 있게 합니다.

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

• 블록 동기화

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized(lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized(lock) {
            return count;
        }
    }
}

volatile

public class VolatileExample {
    private volatile boolean flag = true;

    public void stop() {
        flag = false;  // 다른 스레드에 즉시 반영됨
    }

    public void run() {
        while (flag) {
            // 무한 루프
        }
    }
}

Lock 인터페이스 (ReentrantLock)

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();  // 항상 락을 해제해야 함
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

ReadWriteLock

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Counter {
    private int count = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void increment() {
        lock.writeLock().lock();
        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int getCount() {
        lock.readLock().lock();
        try {
            return count;
        } finally {
            lock.readLock().unlock();
        }
    }
}

Atomic Class

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();  // 원자적 증가
    }

    public int getCount() {
        return count.get();  // 안전하게 값을 읽음
    }
}

Semaphore

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);  // 최대 3개의 스레드만 접근 가능

    public void accessResource() throws InterruptedException {
        semaphore.acquire();
        try {
            // 자원에 접근
        } finally {
            semaphore.release();  // 자원 해제
        }
    }
}

Reference