자바 Thread(스레드) 사용법 & 예제

목차:

1. 스레드(Thread)란 무엇인가?

2. 자바에서의 스레드 사용법

3. 스레드 조작(Manipulating Threads)

4. 다중 스레드 환경에서의 동기화(Synchronization)

5. 자바 스레드 예제

1. 스레드(Thread)란 무엇인가?

스레드(Thread)는 프로그램 내에서 동시에 실행되는 일련의 작업 단위를 말합니다. 스레드는 프로세스 내에서 독립적으로 실행되며, 동시에 여러 작업을 수행할 수 있습니다.

일반적으로 프로그램을 실행할 때, 프로세스는 단일 스레드로 실행되며 작업은 순차적으로 수행됩니다. 하지만 스레드를 사용하면 여러 작업을 동시에 실행할 수 있으므로, 다중 스레드 환경에서 프로세스의 실행 시간을 줄이고 성능을 향상시킬 수 있습니다.

스레드는 자신의 실행 컨텍스트, 스택, 레지스터 등을 가지며, 독립적인 실행 흐름을 갖고 있습니다. 동일한 프로세스 내에서 여러 스레드가 동시에 실행될 수 있고, 각 스레드는 서로 공유되는 메모리 공간에 접근하여 데이터를 공유할 수 있습니다.

스레드는 주로 병렬성을 활용하여 동시에 여러 작업을 처리하기 위해 사용됩니다. 예를 들어, 웹 서버에서 클라이언트 요청을 동시에 처리하는 경우, 각 클라이언트 요청을 스레드로 처리하여 병렬적으로 실행할 수 있습니다.

스레드는 다음과 같은 장점을 가지고 있습니다:

• 빠른 응답 시간: 여러 작업을 동시에 처리함으로써 응답 시간을 단축시킬 수 있습니다.
• 자원 공유: 여러 스레드는 프로세스 내에서 메모리 공간을 공유할 수 있으므로, 데이터 공유와 효율적인 자원 사용이 가능합니다.
• 경제성: 스레드는 프로세스를 생성하는 것보다 경제적으로 생성 및 관리하기 때문에 시스템 자원을 효율적으로 사용할 수 있습니다.

하지만 스레드를 사용할 때 주의해야 할 몇 가지 단점도 있습니다:

• 복잡성: 스레드를 사용하면 동시성 문제와 동기화 문제 등 복잡한 상황에 직면할 수 있습니다.
• 상호작용 문제: 여러 스레드가 동시에 메모리를 수정하는 경우, 데이터 일관성을 유지하기 위한 조치가 필요할 수 있습니다.
• 데드락: 여러 스레드가 상호간에 서로의 작업을 기다리는 상황이 발생하여 무한 대기 상태에 빠질 수 있는 데드락(deadlock) 문제가 있을 수 있습니다.

스레드를 효과적으로 활용하기 위해서는 동기화 문제와 상호작용 문제를 고려하고 적절한 자원 공유 기법을 사용하여 다중 스레드 환경을 관리해야 합니다.

2. 자바에서의 스레드 사용법

자바에서 스레드를 사용하기 위해 java.lang.Thread 클래스를 사용합니다. Thread 클래스는 스레드의 생성 및 제어에 사용되며, 다음과 같은 방법으로 사용할 수 있습니다.

스레드 생성

스레드를 생성하기 위해서는 Thread 클래스를 상속받아서 새로운 클래스를 정의하거나, Runnable 인터페이스를 구현하는 방법을 사용할 수 있습니다.

1. Thread 클래스를 상속받은 방법:

public class MyThread extends Thread {
    public void run() {
        // 스레드에서 실행할 작업을 구현
    }
}

위와 같이 Thread 클래스를 상속받은 자식 클래스에서 run 메서드를 오버라이딩하여 스레드에서 실행할 작업을 구현합니다.

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

public class MyRunnable implements Runnable {
    public void run() {
        // 스레드에서 실행할 작업을 구현
    }
}

위와 같이 Runnable 인터페이스를 구현하는 클래스에서 run 메서드를 구현합니다.

스레드 시작

스레드를 시작하기 위해서는 start 메서드를 호출해야 합니다. start 메서드를 호출하면, 스레드가 독립적으로 실행되며 run 메서드의 코드가 실행됩니다.

public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
}

위의 예제에서 MyThread 클래스는 Thread 클래스를 상속받은 자식 클래스입니다. start 메서드를 호출하여 스레드를 시작합니다.

스레드 제어

스레드를 제어하기 위해 다음과 같은 메서드를 사용할 수 있습니다.

• join(): 해당 스레드가 종료될 때까지 호출한 스레드를 블록합니다.
• yield(): 현재 실행 중인 스레드를 일시적으로 멈추고 다른 스레드에게 실행 기회를 양보합니다.
• sleep(long millis): 현재 실행 중인 스레드를 지정된 시간 동안 멈춥니다.
• interrupt(): 스레드가 블록되어 있는 상태에서 일시적으로 멈추게 하거나, 스레드를 종료시키기 위해 사용됩니다.

public static void main(String[] args) {
    MyThread thread1 = new MyThread();
    MyThread thread2 = new MyThread();

    thread1.start();
    thread2.start();

    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

위의 예제에서 join 메서드를 사용하여 thread1과 thread2가 종료될 때까지 main 스레드를 블록합니다. 이로써 thread1과 thread2가 실행을 마치고 종료된 후에 main 스레드가 계속 진행됩니다.

스레드 우선순위

스레드의 우선순위는 실행할 때 CPU 자원을 얻을 확률을 결정하는데 사용됩니다. 자바에서는 스레드의 우선순위를 1에서 10사이의 값으로 설정할 수 있습니다. 기본적으로 모든 스레드의 우선순위는 5로 설정됩니다.

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running...");
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.setPriority(Thread.MAX_PRIORITY);
        thread2.setPriority(Thread.MIN_PRIORITY);

        thread1.start();
        thread2.start();
    }
}

위의 예제에서 thread1의 우선순위를 최고 우선순위로 설정하고, thread2의 우선순위를 최저 우선순위로 설정하였습니다. 그리고 두 스레드를 시작하면, thread1은 thread2보다 더 많은 CPU 자원을 할당받을 확률이 높아집니다.

동기화

여러 스레드가 공유 데이터에 동시에 접근하여 수정하는 경우, 스레드 간의 데이터 일관성 문제가 발생할 수 있습니다. 이를 해결하기 위해 자바에서는 동기화(synchronization) 기능을 제공합니다. 동기화를 사용하여 한 스레드가 공유 데이터를 사용하는 동안 다른 스레드의 접근을 제한할 수 있습니다.

public class Counter {
    private int count;

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

    public int getCount() {
        return count;
    }
}

위의 예제에서 increment 메서드는 synchronized 키워드를 사용하여 동기화된 메서드로 정의되었습니다. 이로써 한 스레드가 increment 메서드를 호출하여 count를 증가시키는 동안 다른 스레드는 접근을 제한하게 됩니다.

위와 같은 방법으로 자바에서 스레드를 생성, 제어하고 동기화하는 방법을 사용할 수 있습니다. 스레드를 사용하여 병렬성을 활용할 때에는 동기화 문제와 데이터 일관성을 고려하여 적절한 방법을 선택하여 사용해야 합니다.

3. 스레드 조작 (Manipulating Threads)

자바에서는 스레드를 조작하여 스레드의 동작을 제어하고 모니터링할 수 있는 다양한 기능을 제공합니다. 이를 통해 스레드의 실행을 일시 정지, 재개, 중지 등을 할 수 있습니다.

스레드 일시 정지

스레드를 일시 정지시키는 방법으로는 sleep() 메서드와 yield() 메서드를 사용할 수 있습니다.

sleep()

sleep() 메서드는 현재 실행 중인 스레드를 지정된 시간 동안 멈추는데 사용됩니다. 이는 주어진 시간이 경과하거나 interrupt() 메서드가 호출되면 다시 실행되기 시작합니다.

public class SleepThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SleepThread thread = new SleepThread();
        thread.start();
    }
}

위의 예제에서 run() 메서드 내부에서 Thread.sleep(1000)을 호출하여 스레드를 1초 동안 멈추도록 합니다. 이로써 스레드가 실행되면 1부터 5까지 숫자를 출력하고, 1초마다 숫자가 출력되게 됩니다.

yield()

yield() 메서드는 현재 실행 중인 스레드를 일시적으로 멈추고 다른 스레드에게 실행 기회를 양보합니다. 이때 어떤 스레드에게 실행 기회를 양보할지 정확히 결정할 수 없습니다.

public class YieldThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            Thread.yield();
        }
    }

    public static void main(String[] args) {
        YieldThread thread = new YieldThread();
        thread.start();
    }
}

위의 예제에서 run() 메서드 내부에서 Thread.yield()를 호출하여 스레드를 일시 정지시키도록 합니다. 이로써 스레드가 실행되면 1부터 5까지 숫자를 출력하고, 각 숫자 출력 이후에 일시적으로 멈추고 다른 스레드에게 실행 기회를 양보합니다.

스레드 중지

스레드를 중지시키는 방법으로는 stop() 메서드와 interrupt() 메서드를 사용할 수 있습니다. 하지만 stop() 메서드는 사용을 권장하지 않으며, 대신 interrupt() 메서드를 사용하는 것이 좋습니다.

stop()

stop() 메서드는 스레드를 강제로 중지시키는데 사용됩니다. 하지만 이 메서드는 스레드가 실행 중인 상태에서 바로 중지되기 때문에, 스레드가 정리하지 못한 작업이나 블록된 리소스 등을 남길 수 있습니다. 그래서 stop() 메서드는 사용을 권장하지 않습니다.

interrupt()

interrupt() 메서드는 스레드의 interrupted 상태를 설정하여 스레드가 종료될 수 있도록 합니다. 호출된 스레드는 InterruptedException을 던진 후 종료할 수 있습니다.

public class InterruptThread extends Thread {
    public void run() {
        try {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread: " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread Interrupted");
        }
    }

    public static void main(String[] args) {
        InterruptThread thread = new InterruptThread();
        thread.start();

        try {
            Thread.sleep(3000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

위의 예제에서 run() 메서드 내부에서 Thread.sleep(1000)을 호출하여 스레드를 1초 동안 멈추도록 합니다. main 메서드에서는 3초 후에 thread 스레드를 interrupt() 메서드를 호출하여 중지시키도록 합니다. 이후 run 메서드에서 Thread.sleep(1000) 실행 중에 InterruptedException이 발생하면, 스레드가 종료되도록 처리합니다.

스레드 상태

스레드의 상태는 Thread 클래스의 getState() 메서드를 통해 알 수 있습니다. 스레드 상태는 NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED 등으로 정의되며, 각각의 상태는 다음과 같은 의미를 가집니다.

• NEW: 스레드가 아직 시작되지 않은 상태를 의미합니다.
• RUNNABLE: 스레드가 실행 중인 상태를 의미합니다.
• BLOCKED: 스레드가 공유 리소스를 사용하려고 하지만 다른 스레드에 의해 점유되었기 때문에 실행이 불가능한 상태를 의미합니다.
• WAITING: 스레드가 다른 스레드에서 통지를 기다리면서 실행을 멈춘 상태를

  4. 다중 스레드 환경에서의 동기화 (Synchronization)

다중 스레드 환경에서는 여러 스레드가 공유 데이터에 동시에 접근하여 수정하는 경우가 발생할 수 있습니다. 이러한 상황에서 스레드 간의 데이터 일관성을 유지하기 위해 자바에서는 동기화(Synchronization) 기능을 제공합니다. 동기화는 한 스레드가 공유 데이터를 사용하는 동안 다른 스레드의 접근을 제한하여 데이터 일관성을 보장하는 기법입니다.

synchronized 키워드

자바에서 동기화를 구현하는 가장 간단한 방법은 synchronized 키워드를 사용하는 것입니다. synchronized 키워드를 사용하면 메서드 또는 블록을 임계 영역(critical section) 으로 지정할 수 있습니다. 임계 영역은 한 번에 한 스레드만 실행할 수 있는 영역입니다.

메서드 동기화

public class Counter {
    private int count;

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

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

위의 예제에서 increment() 메서드와 getCount() 메서드는 synchronized 키워드를 사용하여 동기화된 메서드로 정의되었습니다. 이로써 한 스레드가 increment() 또는 getCount() 메서드를 호출하여 count 값을 변경하거나 읽는 동안 다른 스레드는 접근을 제한받게 됩니다.

블록 동기화

public class Counter {
    private int count;

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

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

위의 예제에서 increment() 메서드와 getCount() 메서드는 synchronized 블록으로 정의되었습니다. synchronized (this)를 사용하여 임계 영역을 지정합니다. 이로써 한 스레드가 블록 내의 코드를 실행하는 동안 다른 스레드는 접근을 제한받습니다.

잠금(Locks)과 조건(Conditions)

자바에서는 Lock 인터페이스를 사용하여 더 유연한 동기화를 제공합니다. Lock 인터페이스를 사용하면 더 다양한 잠금 및 조건을 사용하여 스레드 동기화를 조작할 수 있습니다.

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

public class Counter {
    private int count;
    private Lock lock;

    public Counter() {
        count = 0;
        lock = new ReentrantLock();
    }

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

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

위의 예제에서는 Lock 인터페이스를 구현한 ReentrantLock 클래스를 사용하여 잠금

5. 자바 스레드 예제

스레드 생성 예제

public class MyThread extends Thread {
    public void run() {
        System.out.println("Hello from MyThread!");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

위의 예제는 MyThread 클래스를 정의하고 run() 메서드를 오버라이드하여 스레드의 실행 로직을 작성한 예제입니다. main 메서드에서 MyThread 객체를 생성하고 start() 메서드를 호출하여 스레드를 실행시킵니다. start() 메서드를 호출하면 새로운 스레드가 시작되고, run() 메서드가 실행됩니다.

스레드 동기화 예제

public class Counter {
    private int count;

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

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

public class SynchronizedThread extends Thread {
    private Counter counter;

    public SynchronizedThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        SynchronizedThread thread1 = new SynchronizedThread(counter);
        SynchronizedThread thread2 = new SynchronizedThread(counter);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

위의 예제는 동기화된 카운터를 사용하는 두 개의 스레드를 생성하는 예제입니다. Counter 클래스는 synchronized 키워드를 사용하여 동기화된 메서드인 increment()과 getCount()를 가지고 있습니다. SynchronizedThread 클래스는 Counter 객체를 생성자로 받아서 increment() 메서드를 호출하여 카운터 값을 증가시킵니다.

main 메서드에서는 Counter 객체를 생성하고 두 개의 SynchronizedThread 객체를 생성하여 카운터를 증가시킵니다. 스레드 실행이 모두 끝난 후에는 카운터의 최종 값을 출력합니다.

스레드 일시 정지 예제

public class SleepThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SleepThread thread = new SleepThread();
        thread.start();
    }
}

위의 예제는 일정한 간격으로 숫자를 출력하는 스레드입니다. run() 메서드에서는 1부터 5까지의 숫자를 출력하고, Thread.sleep(1000)을 호출하여 1초 동안 스레드를 일시 정지시킵니다. 이로써 각 숫자 출력 후 1초의 일시 정지가 발생하게 됩니다.

스레드 중지 예제

public class InterruptThread extends Thread {
    public void run() {
        try {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread: " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread Interrupted");
        }
    }

    public static void main(String[] args) {
        InterruptThread thread = new InterruptThread();
        thread.start();

        try {
            Thread.sleep(3000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

위의 예제는 interrupt() 메서드를 사용하여 스레드를 중지시키는 예제입니다. run() 메서드에서는 1부터 5까지의 숫자를 출력하고, Thread.sleep(1000)을 호출하여 1초 동안 스레드를 일시 정지시킵니다. main 메서드에서는 3초 후에 thread 스레드를 interrupt() 메서드를 호출하여 중지시킵니다. 이후 run 메서드에서 Thread.sleep(1000) 실행 중에 InterruptedException이 발생하면, "Thread Interrupted"라는 메시지를 출력합니다.

5. 자바 스레드 예제

스레드 생성 예제

public class MyThread extends Thread {
    public void run() {
        System.out.println("Hello from MyThread!");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

위의 예제는 MyThread 클래스를 정의하고 run() 메서드를 오버라이드하여 스레드의 실행 로직을 작성한 예제입니다. main 메서드에서 MyThread 객체를 생성하고 start() 메서드를 호출하여 스레드를 실행시킵니다. start() 메서드를 호출하면 새로운 스레드가 시작되고, run() 메서드가 실행됩니다.

이 예제에서는 MyThread 클래스가 Thread 클래스를 상속받아 스레드로 동작하도록 구현되었습니다. Thread 클래스에는 기본적으로 run() 메서드가 있고, 이 메서드를 오버라이드하여 스레드의 동작을 구체적으로 정의할 수 있습니다.

스레드 동기화 예제

public class Counter {
    private int count;

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

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

public class SynchronizedThread extends Thread {
    private Counter counter;

    public SynchronizedThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        SynchronizedThread thread1 = new SynchronizedThread(counter);
        SynchronizedThread thread2 = new SynchronizedThread(counter);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

위의 예제는 동기화된 카운터를 사용하는 두 개의 스레드를 생성하는 예제입니다. Counter 클래스에는 synchronized 키워드를 사용하여 동기화된 메서드인 increment()과 getCount()를 작성했습니다. SynchronizedThread 클래스는 Counter 객체를 생성자로 받아서 increment() 메서드를 호출하여 카운터 값을 증가시킵니다.

main 메서드에서는 Counter 객체를 생성하고 두 개의 SynchronizedThread 객체를 생성하여 카운터를 증가시킵니다. 스레드의 실행이 모두 끝난 후에는 카운터의 최종 값을 출력합니다.synchronized 키워드로 메서드를 동기화함으로써 한 스레드가 해당 메서드를 실행하는 동안 다른 스레드의 접근을 제한하게 됩니다. 이를 통해 공유 데이터에 대한 스레드 간의 일관성을 유지할 수 있습니다.

스레드 일시 정지 예제

public class SleepThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SleepThread thread = new SleepThread();
        thread.start();
    }
}

위의 예제는 sleep() 메서드를 사용하여 스레드를 일시 정지시키는 예제입니다. run() 메서드에서는 1부터 5까지의 숫자를 출력하고, Thread.sleep(1000)을 호출하여 1초 동안 스레드를 일시 정지시킵니다. 이렇게 하면 각 숫자 출력 후 1초씩 일시 정지가 발생하게 됩니다.

sleep() 메서드는 지정된 시간 동안 스레드를 일시 정지시키는 역할을 합니다. Thread.sleep(1000)은 1000밀리초(1초) 동안 스레드를 일시 정지시킨 후 다음 코드를 실행합니다. InterruptedException이 발생할 수 있으므로 예외 처리를 해주어야 합니다.

스레드 중지 예제

public class InterruptThread extends Thread {
    public void run() {
        try {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread: " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread Interrupted");
        }
    }

    public static void main(String[] args) {
        InterruptThread thread = new InterruptThread();
        thread.start();

        try {
            Thread.sleep(3000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

위의 예제는 interrupt() 메서드를 사용하여 스레드를 중지시키는 예제입니다. run() 메서드에서는 1부터 5까지의 숫자를 출력하고, Thread.sleep(1000)을 호출하여 1초 동안 스레드를 일시 정지시킵니다. main 메서드에서는 3초 후에 thread 스레드를 interrupt() 메서드를 호출하여 중지시킵니다.

interrupt() 메서드는 해당 스레드를 중지시키는 역할을 합니다. 예제에서는 thread.interrupt()를 호출하여 thread 스레드를 중지시킵니다. run 메서드에서 Thread.sleep(1000) 실행 중에 InterruptedException이 발생하면, catch 블록이 실행되고 "Thread Interrupted"라는 메시지가 출력됩니다.

5. 자바 스레드 예제

스레드 생성 예제

public class MyThread extends Thread {
    public void run() {
        System.out.println("Hello from MyThread!");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

이 예제에서는 MyThread 클래스를 정의하고 run() 메서드를 오버라이딩하여 스레드의 실행 로직을 작성했습니다. main 메서드에서는 MyThread 객체를 생성하고 start() 메서드를 호출하여 스레드를 실행시켰습니다. start() 메서드를 호출하면 새로운 스레드가 시작되고, 해당 스레드의 run() 메서드가 실행됩니다.

이 예제에서 MyThread 클래스는 Thread 클래스를 상속받아 스레드로 동작하도록 구현되었습니다. Thread 클래스는 기본적으로 run() 메서드를 가지며, 이 메서드를 오버라이딩하여 스레드가 동작할 내용을 구체적으로 정의할 수 있습니다.

스레드 동기화 예제

public class Counter {
    private int count;

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

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

public class SynchronizedThread extends Thread {
    private Counter counter;

    public SynchronizedThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();

        SynchronizedThread thread1 = new SynchronizedThread(counter);
        SynchronizedThread thread2 = new SynchronizedThread(counter);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

위의 예제는 동기화된 카운터를 사용하는 두 개의 스레드를 생성하는 예제입니다. Counter 클래스는 synchronized 키워드를 사용하여 동기화된 increment()과 getCount() 메서드를 가지고 있습니다. SynchronizedThread 클래스는 Counter 객체를 생성자로 받아서 increment() 메서드를 호출하여 카운터 값을 증가시킵니다.

main 메서드에서는 Counter 객체를 생성하고 두 개의 SynchronizedThread 객체를 생성하여 카운터를 증가시킵니다. 스레드의 실행이 모두 끝난 후에는 카운터의 최종 값을 출력합니다. synchronized 키워드를 사용하여 메서드를 동기화하면 한 스레드가 해당 메서드를 실행하는 동안 다른 스레드의 접근을 제한할 수 있습니다. 이를 통해 공유 데이터에 대한 스레드 간의 일관성을 유지할 수 있습니다.

스레드 일시 정지 예제

public class SleepThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SleepThread thread = new SleepThread();
        thread.start();
    }
}

위의 예제는 sleep() 메서드를 사용하여 스레드를 일시 정지시키는 예제입니다. run() 메서드에서는 1부터 5까지의 숫자를 출력하고, Thread.sleep(1000)을 호출하여 1초 동안 스레드를 일시 정지시킵니다. 이렇게 하면 각 숫자 출력 후 1초씩 일시 정지가 발생하게 됩니다.

sleep() 메서드는 지정된 시간 동안 스레드를 일시 정지시키는 역할을 합니다. Thread.sleep(1000)은 1000밀리초(1초) 동안 스레드를 일시 정지시킨 후 다음 코드를 실행합니다. InterruptedException이 발생할 수 있으므로 예외 처리를 해주어야 합니다.

스레드 중지 예제

public class InterruptThread extends Thread {
    public void run() {
        try {
            for (int i = 1; i