Thread😶

오늘 배울거...📁
1. Thread가 무엇인가?
2. 중요한 용어, class와 method
3. Network Server를 만들기 위해 활용

Thread가 무엇인가?

Process

• 실행중인 프로그램
• 프로그램을 실행시키기 위해 OS로부터 resource를 할당 받아야 한다.
  • code (프로그램 실행 코드)
  • data (프로그램을 실행하기 위한 데이터)
  • heap
  • stack
• process 내에는 최소 1개 이상의 thread가 존재한다.
  • single-thread-process ( thread가 딱 1개 존재 )
    
  • multi-thread-process ( thread가 2개 이상 존재 )
• Process
  resource + thread ( 최소 1개 이상 )

Thread

• thread는 excution stack을 별도로 가지고 있는 실행 흐름을 말한다.
• 독립적인 code를 실행하는 실행 흐름이기 때문에 thread마다 별도의 stack이 할당된다.
• 우리가 지금까지 만든 코드는 싱글 스레드 하나가 main 메서드를 통해 프로그램을 동작시켰다.
• 여기서 main이 여러개 만들어 동시에 실행시켜본다는 개념이 적용된다면 멀티 스레드가 된다.
• 단일 스레드와 멀티 스레드를 비교해보았을 때, 여러가지 일을 동시에 수행하는 측면에서 멀티 스레드가 더 효율적이라고 할 수 있다.

그렇다면, Thread가 많을수록 좋을까?🙄

그렇지는 않다. 왜냐하면 각각의 스레드마다 stack 영역이 따로 할당되기 때문이다. thread가 많으면 많을수록 stack 영역을 쪼개서 주어야 한다. 이 점에서 resource가 부족해지게 된다. 따라서 적당한 양이 좋다.

CPU (core)

core

• CPU의 core는 한 순간에 한가지 일만 수행할 수 있다.

time slicing

만약 내가 사용하는 컴퓨터가 single core라면, core는 하나인데 여러개의 프로그램이 마치 동시에 실행되는 것처럼 보인다. 어떻게..?

시간을 쪼개서 마치 동시에 실행되는 것처럼 하는 것이다. 이는 Multi tasking (core의 개수와 상관X) 이다.

multi processing

진짜 여러개의 프로그램이 동시에 실행, core가 2개 이상일때만 가능하다.

multi threading

하나의 프로그램이 여러개의 thread가 존재할 때, 시간상 동시에 실행되는 것처럼 하는 것이다.

Multi-threading

[장점]

• 효율적인 처리가 가능하다.
• 응답속도가 빠르다.

[단점]

• 공유 자원에 대한 동기화 처리를 해야하기 때문에 프로그램이 어렵다.
• dead lock등의 문제가 발생한다.

Java에서 Thread를 만들어 사용하려면..어떻게..?😮

JVM이 Thread를 생성 -> Thread가 main( ) 메서드를 호출한다.

• 메서드 자체를 Thread와 동일시하면 안된다.
• main( ) 메서드는 main thread에 의해서 실행된다.

• Java에서의 thread는 instance다.
• 해당 instance를 만들어내는 class가 존재함을 의미한다.
• 해당 Thread를 만들어내는 class가 바로 Thread class다.

[Java로 thread 만드는 방법]

[ 방법 1 ]

• Thread class를 상속해서 user-define thread class를 만들어서 이용하는 방법이 있다.
  • 일반적인 방법은 아니다.
  • Java는 다중상속이 불가능하기 때문에 다른 클래스를 사용하는데에 제약이 생긴다.
  • 클래스끼리 tightly coupled 문제가 발생하여 재사용에 제약이 생긴다.

[ 방법 2 ]

• Runable interface를 구현해서 user-define class를 만든다.
  • 이 클래스가 Thread 되는 것은 아니다.
• user-define class의 instance를 만든다.
  • new Thread( )를 통해 할당하여 사용한다.
  • 위 객체를 가지고 Thread class의 인자로 넘긴다.

[방법1] 코드로 살펴보기 (상속)

package lecture0714;
class MyThread extends Thread{

	@Override
	public void run() {
		System.out.println("Hello");
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		MyThread t = new MyThread();
//		t.run(); // 인스턴스의 메서드 호출
		t.start(); // 1. thread 생성 2. stack 호출 3. run()호출
        
        System.out.println("안녕하세요!");
        // 실행 순서를 보장하지 못한다.
	}
}

[방법2] 코드로 살펴보기 (Runnable)

package lecture0714;
class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println("Hello");
	}
}

class MyThread2 implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("이것도 실행되요!");
	}
}
public class Main {
	
	public static void main(String[] args) {
		
		MyThread t = new MyThread();
//		t.run(); // 인스턴스의 메서드 호출
		t.start(); 
		
		MyThread2 a = new MyThread2();

		Thread t1 = new Thread(a); // Thread 객체에 인자 넘기기 -> 실제 Thread 객체 만들기
		t1.start();
		
		System.out.println("안녕하세요!");
	}
}

t.start( );

1. thread 생성
2. stack 호출
3. run( ) 호출

thread의 실행 순서

어떤 메서드가 먼저 실행될지에 대해서는 스케줄러에 의해서 결정된다.
따라서 수행 순서를 보장하지 못한다.

코드로 살펴보기 (실행중인 스레드 이름 출력)

package lecture0714;

class ThreadEx_01_1 extends Thread{
	@Override
	public void run() {
		for (int i=0; i<5; i++) {
			System.out.println(getName()); // 스레드의 이름을 알아내는 메서드
		}
	}
}
class ThreadEx_01_2 implements Runnable{
	@Override
	public void run() {
		for (int i=0; i<5; i++) {
			
			System.out.println(Thread.currentThread().getName()); 
			// 아직 스레드가 아니여서 this.getName() 사용 못함.
			// 스레드가 가지고 있는 static 메서드 사용
			// 이 코드가 실행되는데 현재 실행되고 있는 스레드를 지칭함
		}
	}
}
public class ThreadExam01 {
	public static void main(String[] args) {
		
		ThreadEx_01_1 t1 = new ThreadEx_01_1();
		
		ThreadEx_01_2 r = new ThreadEx_01_2();
		Thread t2 = new Thread(r);
		
		t1.start();
		t2.start();
		
		System.out.println("main thread 종료");
	}
}

// 어떤 스레드가 먼저 실행되는지 알 수 없다.
// 스케줄러에 의해서 선택되어서 실행되기 때문에 어떤게 선택되는지 알 수 없다.

thread 상태 전이도

Process의 종료

내부에서 파생된 모두 user define thread가 종료되는 순간 process가 종료된다.

single core

• 처리해야할 작업이 2개 (A, B)
  

왼쪽 그림은 single thread를 사용하는 것이고, 오른쪽 그림은 2개의 thread를 이용해 작업을 수행한다.

• 오른쪽 그림으로 수행할 경우, 두 작업이 동시에 실행되는 것과 같은 효과가 난다.

• 속도면에서 왼쪽 사진이 더 빠르다.
  왜? context switching이 일어나지 않기 때문이다.

multi core (core 2개)

• 대부분은 multi core가 되어있다.
• 공유자원의 처리에 대한 문제가 있지만 속도면에서 이점이 있다.

public class ThreadExam01 {
	public static void main(String[] args) {
		
		ThreadEx_01_1 t1 = new ThreadEx_01_1();
		
		ThreadEx_01_2 r = new ThreadEx_01_2();
		Thread t2 = new Thread(r);
		
		// multi-core 환경에서는 우선순위의 의미가 없다 
        // (single core에서만 적용되고 의미있음)
        // minimu = 0, maximum = 10 클수록 우선순위가 높다
		t1.setPriority(10);
		t2.setPriority(2);
        
		t1.start();
		t2.start();
		
		System.out.println("main thread 종료");
	}
}

Daemon Thread (데몬 스레드)

다른 일반 Thread에 보조적인 작업을 위해 사용한다.

• Daemone Thread를 파생시킨 thread가 종료되면 따라서 종료된다.
• main thread가 dead 상태가 되면 끝나지 않았어도 같이 종료된다.
• 대표적인 daemon thread의 예
  1 ) garbage collector
  garbage collector는 반복적으로 작업이 수행되고 있다가 메인이 종료되면 같이 종료된다.
  2 ) 워드 프로세서의 자동저장

t1.setDaemon(true);

코드로 살펴보기 (Daemon Thread)

package lecture0714;

// Daemon Thread에 대해서 알아보아요!
public class ThreadExam02 implements Runnable {
	
	static boolean autoSave = false;
	
	public static void main(String[] args) {
		Thread t = new Thread(new ThreadExam02());
		
		t.setDaemon(true); // 데몬 스레드로 바꾸어주기
		
		t.start();
		for (int i=0; i<10; i++) {
			try {
				Thread.sleep(1000); // 현재 실행하고 있는 스레드를 재움 (여기서는 main 스레드가 sleep)
			}catch(Exception e) {
			}
			System.out.println(i);
			
			if (i == 5) {
				autoSave = true;
			}
		}
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(3000); // t Thread를 sleep 시킴 
			} catch(InterruptedException e) {
				
			}
			
			if(autoSave) {
				System.out.println("자동저장되었어요!");
			}
		}
	}
}

기억해야하는 thread의 method

• 생성
• start( )
• sleep( )
• stop( ) (아래 3개 이제 안 씀 ❌)
  1 ) stop( ) - Thread의 종료(강제)
  2 ) suspend( ) - Thread의 일시중지
  3 ) resume( ) - 일시중지된 Thread의 재시작
• interrupt( ), interrupted( ) [확인] , isInterrupted( ) [확인]
• yield( )

1. sleep( long millisecond )

• 일정시간동안 thread를 중지시킨다.
• 'sleep'에서 깨어나는 경우
  • 지정된 시간이 다 되는 경우
  • 해당 스레드에 대해 interrupt( )가 호출되면 해당 스레드에 대해서 interruptedException이 발생하는 경우
• sleep에서 깨어나는 경우에는 Runnable 상태로 간다.

sleep에 대한 상태전이도

package lecture0714;

class ThreadEx_03_1 extends Thread {
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("<<Thread 1 종료>>");
	}
}

class ThreadEx_03_2 extends Thread {
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
		System.out.println("<<Thread 2 종료>>");
	}
}

public class ThreadExam03{
	public static void main(String[] args) {
		ThreadEx_03_1 t1 = new ThreadEx_03_1();
		ThreadEx_03_2 t2 = new ThreadEx_03_2();
		
		t1.start();
		t2.start();
		
		try {
			t1.sleep(2000); // 현재 실행되는 스레드를 재우는 것 
							// -> 특정 스레드가 아닌 main 스레드가 재우게 됨
		}catch (Exception e) {
			
		}
		System.out.println("<<main Thread 종료>>");
	}
}

올바른 sleep 위치 예시 코드

package lecture0714;

class ThreadEx_03_1 extends Thread {
	@Override
	public void run() {
    	try {
        	Thread.sleep(2000);
        }catch (Exception e) {
        }
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("<<Thread 1 종료>>");
	}
}

class ThreadEx_03_2 extends Thread {
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
		System.out.println("<<Thread 2 종료>>");
	}
}

public class ThreadExam03{
	public static void main(String[] args) {
		ThreadEx_03_1 t1 = new ThreadEx_03_1();
		ThreadEx_03_2 t2 = new ThreadEx_03_2();
		
		t1.start();
		t2.start();
		
		System.out.println("<<main Thread 종료>>");
	}
}
//2초 동안 Thread1 자고있음
// main 스레드 실행
// Thread2 실행
// Thread1 실행

2. interrupt( )

• stop( ) -> thread 강제 중지 -> X, 사용불가 ( deprecated )
• start( ) -> thread 시작! (이것만 사용가능)

thread 실행 후 작업이 끝나기 전에 해당 thread를 중지시키고 싶을 때 사용한다.

• interrupt( )를 이용 -> 직접 중지시키지 않는다.
• thread의 내부 상태값인 Interrupted State를 true로 바꿔준다.
  (이후 내부 로직을 통해 Thread를 중지한다)

thread가 interrupt가 되었는지 확인하는 메서드

• interrupted( ) : Thread의 static (클래스 메서드)
  현재 수행중인 thread가 interrupt가 걸렸는지 알아볼 수 있다. 특정 스레드를 지칭할 수 없다...
  상태값을 조사하고 그 상태값을 false로 바꾼다. (조심~🙋‍♀️)
• isInterrupted( ) : static이 아니다.
  특정 스레드를 지칭해서 interrupt가 걸렸는지 여부를 알 수 있다
  상태값만 true/false로 return 해준다

package lecture0714;

import javax.swing.JOptionPane;

class ThreadEx_04 extends Thread{
	@Override
	public void run() {
		int i = 10;
		while (i != 0 && !isInterrupted()) {
			System.out.println(--i);
            
            // 이 부분 너무 구려요.. 밑에서 바꿔봐요..!
			for(long k=0; k<2500000000L; k++) { // 시간지연
			}
		}
		System.out.println("카운트가 종료되었어요");
	}
}

public class ThreadExam04 {
	public static void main(String[] args) {
		Thread t = new ThreadEx_04();
		t.start();
		
		String input = JOptionPane.showInputDialog("값을 입력하세요!");
		System.out.println("입력값은 : "+input);
		
		t.interrupt();
		// Thread t의 interrupt 상태가 true가 된다.
		System.out.println("Thread 상태값은 : "+t.isInterrupted());
	} 
}

/*
9
8
7
6
5
4
3
입력값은 : 14
Thread 상태값은 : true
카운트가 종료되었어요
*/

sleep에서 interrupt가 걸리는 경우

package lecture0714;

import javax.swing.JOptionPane;

class ThreadEx_04 extends Thread{
	@Override
	public void run() {
		int i = 10;
		while (i != 0 && !isInterrupted()) {
			System.out.println(--i);

//			for(long k=0; k<2500000000L; k++) { // 시간지연
//			}
			// sleep 이용한 코드로 대체 가능합니다~!
            // 그런데 문제가 생깁니다..
			try {
				Thread.sleep(4000);
				// 자고 있을 때 interrupt가 걸린다.
				// 일어나게 되면 자기의 intrrupted 상태를 false로 초기화시킨다.
				// 따라서 sleep을 사용하게 되면, 숫자가 중단되지 않고 계속 돌아간다.
			} catch(Exception e) {
           		// interrupt가 false인 상태로 되어 있다.
				// 따라서 catch문에서 interrupt를 한 번 더 걸어줘야 된다.
				interrupt();
			}
		}
		System.out.println("카운트가 종료되었어요");
	}
}

public class ThreadExam04 {
	public static void main(String[] args) {
		Thread t = new ThreadEx_04();
		t.start();
		
		String input = JOptionPane.showInputDialog("값을 입력하세요!");
		System.out.println("입력값은 : "+input);
		
		t.interrupt();
		// Thread t의 interrupt 상태가 true가 된다.
		System.out.println("Thread 상태값은 : "+t.isInterrupted());
	} 
}

/*
9
8
7
6
5
4
3
입력값은 : 14
Thread 상태값은 : true
2
1
카운트가 종료되었어요
*/

3. stop( ), suspend( )

지금은 사용하지 않은 메서드다.
하지만 로직을 파악하기 위해 코드를 작성해보자.

package lecture0714;

class ThreadEx_05 implements Runnable{
	@Override
	public void run() {
		while(true) {
			System.out.println(Thread.currentThread().getName());
			try {
				Thread.sleep(1000);
			}catch(Exception e) {
				
			}
		}
		
	}
}
public class ThreadExam05 {
	public static void main(String[] args) {
		ThreadEx_05 r = new ThreadEx_05();
		
		// thread 3개
		Thread t1 = new Thread(r,"*"); // 두 번째 인자는 thread의 이름
		Thread t2 = new Thread(r,"**");
		Thread t3 = new Thread(r,"***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);
			t1.suspend(); // t1을 일시 중지
			Thread.sleep(2000);
			t2.suspend(); // t2를 일시 중지
			Thread.sleep(2000);
			t1.resume(); // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			t1.stop();
			t2.stop();
			Thread.sleep(2000);
			t3.stop();
		} catch (Exception e) {
			
		}
	}
}

로직으로 같은 코드 짜보기

package lecture0714;

/* 같은 동작 로직으로 바꿔보자 */
class ThreadEx_06 implements Runnable{
	
	// boolean suspended = false;
	// boolean stopped = false;
  	volatile boolean suspended = false;
	volatile boolean stopped = false;
	
	@Override
	public void run() {
		while(!stopped) {
			if (!suspended) {
				System.out.println(Thread.currentThread().getName());
				try {
					Thread.sleep(1000);
				}catch(Exception e) {
					
				}
			}
			
		}
		
	}
	
	public void suspend() {
		suspended = true;
	}
	
	public void stop() {
		stopped = true;
	}
	
	public void resume() {
		suspended = false;
	}
}
public class ThreadExam06 {
	public static void main(String[] args) {
		ThreadEx_06 r1 = new ThreadEx_06();
		ThreadEx_06 r2 = new ThreadEx_06();
		ThreadEx_06 r3 = new ThreadEx_06();
		
		// thread 3개
		Thread t1 = new Thread(r1,"*"); // 두 번째 인자는 thread의 이름
		Thread t2 = new Thread(r2,"**");
		Thread t3 = new Thread(r3,"***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);
			r1.suspend(); // t1을 일시 중지
			Thread.sleep(2000);
			r2.suspend(); // t2를 일시 중지
			Thread.sleep(2000);
			r1.resume(); // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			r1.stop();
			r2.stop();
			Thread.sleep(2000);
			r3.stop();
		} catch (Exception e) {
			
		}
	}
}

로직에 문제가 없는데 코드가 일부 이상하게 동작한다.
다음은 멀티코어 프로세스에서 동작하는 로직이다.

volatile 키워드

값이 변경되면 cache가 아닌 memory에서 변수를 가져오라는 키워드 붙는다.

4. yield( )

Thread가 자신에게 주어진 실행시간을 다 쓰지않고 다른 Thread에게 양보해준다.

package lecture0714;

/* 같은 동작 로직으로 바꿔보자 */
class ThreadEx_06 implements Runnable{
	
	volatile boolean suspended = false;
	volatile boolean stopped = false;
	
	@Override
	public void run() {
		while(!stopped) {
			if (!suspended) {
				System.out.println(Thread.currentThread().getName());
				try {
					Thread.sleep(1000);
				}catch(Exception e) {
					
				}
			} else {
				Thread.yield(); // 양보를 통해 busy waiting을 피할 수 있다.
			}
			
		}
		
	}
	
	public void suspend() {
		suspended = true;
	}
	
	public void stop() {
		stopped = true;
	}
	
	public void resume() {
		suspended = false;
	}
}
public class ThreadExam06 {
	public static void main(String[] args) {
		ThreadEx_06 r1 = new ThreadEx_06();
		ThreadEx_06 r2 = new ThreadEx_06();
		ThreadEx_06 r3 = new ThreadEx_06();
		
		// thread 3개
		Thread t1 = new Thread(r1,"*"); // 두 번째 인자는 thread의 이름
		Thread t2 = new Thread(r2,"**");
		Thread t3 = new Thread(r3,"***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);
			r1.suspend(); // t1을 일시 중지
			Thread.sleep(2000);
			r2.suspend(); // t2를 일시 중지
			Thread.sleep(2000);
			r1.resume(); // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			r1.stop();
			r2.stop();
			Thread.sleep(2000);
			r3.stop();
		} catch (Exception e) {
			
		}
	}
}

yield에 대한 상태전이도

5. join( )

• 수행되고 있는 thread가 다른 특정 thread를 지정해서 그 thread를 먼저 수행시키는 메서드다. ( instance method )
• sleep은 static method 이므로 특정 thread를 재울 수 없고, 현재 실행되는 thread를 재울 수 있다.

1. join( )
2. join(long 초)

join( ) 코드로 살펴보기

package lecture0715;

class ThreadEx_07_1 extends Thread{
	@Override
	public void run() {
		for (int i=0; i<300; i++) {
			System.out.print("-");
		}
	}
}
class ThreadEx_07_2 extends Thread{
	@Override
	public void run() {
		for (int i=0; i<300; i++) {
			System.out.print("|");
		}
	}
}
public class ThreadExam07 {
	public static void main(String[] args) {
		Thread t1 = new ThreadEx_07_1();
		Thread t2 = new ThreadEx_07_2();
		
		t1.start();
		t2.start();
		
		try {
			// 내가 수행되는 것을 hold 시키고, 지정한 thread가 동작하게 함
			// 실행중인 main thread를 일시적으로 block시킴
			// blocked된 thread를 Runnable 상태로 변환시키기 위해 try-catch문 사용함
			t1.join();
			t2.join();
		} catch (Exception e) {
			// TODO: handle exception
		}
		System.out.println("<<main>> 종료"); 
	}
}

join( ) 상태전이도

join문을 언제 사용하면 좋을까?

코드로 살펴보아요

package lecture0715;

class ThreadEx_08_1 extends Thread{
	
	final static int MAX_MEMORY = 1000;
	int usedMemory = 0;
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(10000); // 10초 동안 자요!
			} catch (Exception e) {
				System.out.println("interrupt에 의해서 깨어났어요!");
			}
			gc();
			System.out.println("메모리 청소 완료! 현재 사용 가능한 메모리량은:"
					+ freeMemory());
		} 
	}
	public void gc() {
		usedMemory -= 300;
		if(usedMemory < 0) {
			usedMemory = 0;
		}
	}
	public int totalMemory() {
		return MAX_MEMORY;
	}
	public int freeMemory() {
		return MAX_MEMORY - usedMemory;
	}
}
public class ThreadExam08 {
	public static void main(String[] args) {
		ThreadEx_08_1 t1 = new ThreadEx_08_1();
		t1.setDaemon(true);
		t1.start();
		
		int requiredMemory = 0;
		
		for(int i=0; i<20; i++) {
			requiredMemory = ((int)(Math.random() * 10)) * 20;
							 // 0.0보다 같거나 크고 200보다 작은 정수
			
			// 필요한 memory가 사용할 수 있는 양보다 크거나 
			// 현재 전체 메모리양의 60%이상을 사용하고 있을 때 gc를 실행
			if ((t1.freeMemory() < requiredMemory) ||
					(t1.freeMemory() < t1.totalMemory() * 0.4)) {
				t1.interrupt(); // 여기서 gc() 실행이 끝날때까지 기다리지 않아요!
				try {
					t1.join(100);
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
			// 청소가 되었으니 메모리양을 사용할 수 있음
			t1.usedMemory += requiredMemory;
			System.out.println("사용된 메모리량 :" +t1.usedMemory);
		}
	
	}
}

Thread의 동기화

하나의 객체를 여러개의 thread가 공용으로 사용하는 것이다.

T1이 1번을 선택하고 카드 결제하고 있는 와중에는 다른 T가 방해하지 못하도록 막아줘야 된다.

1 ) Critical section(임계 영역)을 설정해주어야 한다.
2 ) Lock(Monitor)을 도입해서 임계 영역을 설정할 수 있다.

6. Lock( )

• T1이 Lock을 가져가서 다른 T가 공용 데이터를 사용하지 못 하도록 한다.
• T1이 작업을 끝맞치면 Lock을 반납하고, 대기상태에 있던 다른 T가 Lock을 잡는다.
• 획득하지 못한 다른 T는 또 대기를 한다.
• 따라서 Lock을 얻어서 임계영역을 설정할 수 있다.
• Java에서 "Lock"을 얻어 임계영역을 설정하려면 synchronized 키워드를 이용한다.

Synchronized(동기화)

1. method 동기화
2. 동기화 block을 생성 (더 효율이 좋음)

1. method 동기화 코드 (은행 출금)

package lecture0715;

// Thread에 의해서 공유되는 공유객체를 생성하기 위한 class
class Account{
	private int balance = 1000; //계좌 잔액
	public int getBalance() {
		return balance;
	}
	// 출금하는 method => 동기화 처리
	public synchronized void withdraw(int money) {
		if (balance >= money) {
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				// TODO: handle exception
			}
			balance -= money;
		}
	}
}
class ThreadEx_09 implements Runnable{
	Account acc = new Account();
	
	@Override
	public void run() {
		while(acc.getBalance()>0) {
			int money = ((int)(Math.random() * 3 + 1)*100);
			acc.withdraw(money);
			System.out.println("남은 잔액 :" + acc.getBalance());
		}	
	}
}
public class ThreadExam09 {
	public static void main(String[] args) {
		ThreadEx_09 r = new ThreadEx_09(); // runnable 객체
		
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		
		t1.start();
		t2.start();
	}
	
}

만약 synchronized된 메서드의 코드가 길 경우,
메서드 안에는 동기화가 필요한 코드와 불필요한 코드가 혼재한다.
따라서 효율을 위해 동기화가 필요한 부분만 동기화를 시켜 범위를 줄여줄 수 있다.

아래와 같은 코드가 그 작업을 수행한 부분이다.

2. 동기화 블록 코드

// Thread에 의해서 공유되는 공유객체를 생성하기 위한 class
class Account{
	private int balance = 1000; //계좌 잔액
	public int getBalance() {
		return balance;
	}
	// 출금하는 method => 동기화 처리
	public void withdraw(int money) {
		// 동기화 블록
		synchronized(this) { // 인자에는 어떤 객체에 대해 동기화 할지
			if (balance >= money) {
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					// TODO: handle exception
				}
				balance -= money;
			}
		}
	}
}

Synchronized의 비효율

Synchronized를 이용해서 공유 데이터를 보호하는 것은 좋은 부분이다.
하지만 Thread가 공유자원에 대한 Lock을 획득한 후 별다른 일을 하지않고 오랜시간 lock만 계속 들고 있는 경우가 있다. 즉, 기다리고 있는 다른 Thread에 대해서 starvation 문제가 발생할 수 있다.

이를 해결하기 위한 2가지 메서드가 존재한다.

1. wait( ) - Lock을 놓고 일시 대기 상태로 놓일 수 있게 하는 메서드
2. notify( ) - 대기상태에 있는 Thread가 실행될 수 있도록 block을 해제하는 메서드