[JAVA][패스트캠퍼스] Thread구현하기

김주현·2021년 5월 8일
Javafastcampus
0

Thread란?

  • Process
    - 실행중인 프로그램
    - OS로부터 메모리를 할당받음
  • Thread
    - 실제 프로그램이 수행되는 작업의 최소단위
    - 하나의 프로세스는 하나이상의 Thread를 가지게 됨

Thread 구현하기

  • 자바 Thread 클래스로부터 상속받아 구현
  • Runnable 인터페이스 구현
class MyThread implements Runnable{
//	방법2. implements Runnable하는 법
	@Override
	public void run() {
		int i;
		for(i=0;i<=200;i++) {
			System.out.print(i+"\t");
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
// 방법1. extends Thread하는 법
//	public void run() {
//		int i;
//		for(i=0;i<=200;i++) {
//			System.out.print(i+"\t");
//			try {
//				sleep(10);
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			}
//		}
//	}
}





public class ThreadTest {

	public static void main(String[] args) {
		//스레드는 총 3개로 메인스레드 start,end먼저 실행하고 첫번째스레드,두번째스레드 실행함
		System.out.println("start");
//		MyThread th1=new MyThread();
//		MyThread th2=new MyThread();
//		th1.start();
//		th2.start();
		MyThread runner1=new MyThread();
		Thread th1=new Thread(runner1);
		th1.start();
		
		MyThread runner2=new MyThread();
		Thread th2=new Thread(runner2);
		th2.start();
		
		System.out.println("end");
		
	}
}

Multi-thread 프로그래밍

  • 동시에 여러 개의 Thread가 수행되는 프로그래밍
  • Thread는 각각의 작업공간(context)를 가짐
  • 공유 자원이 있는 경우 race condition이 발생
  • critical section에 대한 동기화(synchronization)의 구현이 필요

Thread의 여러가지 메서드 활용

  • Runnable한 상태가 아니면 cpu를 점유할 수 없음
  • thread가 cpu를 점유할 수 없게 된 상태를 Not Runnable이라고 함
  • (sleep,wait,join)세가지의 메서드에 의해 Not Runnable 상태로 빠지게 됨
  • 다시 Runnable상태로 돌아오려면 sleep은 시간이 지나면 돌아오고, wait은 notify나 notifyall메서드가 호출이 되면 돌아오고, join은 다른스레드가 끝나게 되면 돌아옴
  • 다시 Runnable상태로 못돌아오고 좀비상태로 된 thread는 interrupt 인셉션을 날리면 예외처리되서 나오게됨

Thread 우선순위

  • 그냥 실행하게 되면 NORMAL_PRIORITY 5를 가지게 됨

join() 메서드

  • 다른 Thread의 결과를 보고 진행해야 하는 일이 있는 경우 join() 메서드를 활용
  • join() 메서드를 호출한 thread가 non-runnable상태가 됨
public class JoinTest extends Thread{
	
	int start;
	int end;
	int total;
	
	public JoinTest(int start, int end) {
		this.start=start;
		this.end=end;
	}
	
	public void run() {
		int i;
		for(i=start;i<=end;i++) {
			total += i;
		}
	}
	
	public static void main(String[] args) {
		JoinTest jt1=new JoinTest(1, 50);
		JoinTest jt2=new JoinTest(51, 100);
		
		jt1.start();
		jt2.start();
		
		try {
			jt1.join();
			jt2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		int total=jt1.total+jt2.total;
		System.out.println("jt1.total = "+ jt1.total);
		System.out.println("jt2.total = "+ jt2.total);
		
		System.out.println(total);
	}

}

interrupt() 메서드

  • 다른 thread에 예외를 발생시키는 interrupt를 보냄
  • thread가 join(),sleep(),wait() 메서드에 의해 블럭킹 되었다면 interrupt에 의해 다시 runnable상태가 될 수 있음
public class InterruptTest extends Thread{
	
	public void run() {
		int i;
		for(i=0;i<100;i++) {
			System.out.println(i);
		}
		try {
			sleep(5000);
		} catch (InterruptedException e) {
			System.out.println(e);
			System.out.println("Wake!!!");
		}
	}
	public static void main(String[] args) {
		
		InterruptTest test= new InterruptTest();
		test.start();
		test.interrupt();
		
		System.out.println("end");
	}

}

Thread 종료하기

  • 데몬 등 무한 반복하는 thread가 종료될 수 있도록 run() 메서드 내의 while문을 활용
  • Thread.stop()은 사용하지 않음
public class TerminateThread extends Thread{

	private boolean flag=false;
	int i;
	
	public TerminateThread(String name) {
		super(name);
	}
	
	public void run() {
		while(!flag) {
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println(getName()+"end");
	}
	
	public void setFlag(boolean flag) {
		this.flag=flag;
	}
	
	public static void main(String[] args) throws IOException {
		TerminateThread threadA=new TerminateThread("A");
		TerminateThread threadB=new TerminateThread("B");
		
		threadA.start();
		threadB.start();
		
		int in;
		while(true) {
			in=System.in.read();
			if(in == 'A') {
				threadA.setFlag(true);
			}
			else if(in == 'B') {
				threadB.setFlag(true);
			}else if( in == 'M') {
				threadA.setFlag(true);
				threadB.setFlag(true);
				break;
			}
//			else {
//				System.out.println("try again");
//			}
		}
		System.out.println("main end");
	}

}

임계 영역 (critical section)

  • 두 개 이상의 thread가 동시에 접근하게 되는 리소스
  • critical section과 동시에 thread가 접근하게 되면 실행결과를 보장할 수 없음
  • thread간의 순서를 맞추는 동기화(synchronization)이 필요

동기화 (synchronization)

  • 임계 영역에 여러 thread가 접근하는 경우 한 thread가 수행하는 동안 공유 자원을 lock하려 다른 thread의 접근을 막음
  • 동기화를 잘못 구현하면 deadlock에 빠질 수 있음

자바에서 동기화 구현

  • synchronized 수행문과 synchronized 메서드를 이용
  • synchronized 수행문
    synchronized(참조형 수식){ }
    참조형 수식에 해당되는 객체에 lock을 건다
  • synchronized 메서드
    - 현재 이 메서드가 속해 있는 객체에 lock을 건다.
    - synchronized 메서드 내에서 다른 synchronized 메서드를 호출하지 않는다.(deadlock 방지위해)

방식1. synchronized 메서드방식


class Bank{
	private int money=10000;
	
	//saveMoney가 수행되는 동안 다른쓰레드가  Bank에 접근못하게함
	//Park이 실행되는 동안 ParkWife는 접근못함
	public synchronized void saveMoney(int save) {
		int m=this.getMoney();
		
		try {
			Thread.sleep(3000);
		}catch(InterruptedException e){
			e.printStackTrace(); 
		}
		
		setMoney(m+save);
	}
	
	public synchronized void minusMoney(int minus) {
		int m=this.getMoney();
		
		try {
			Thread.sleep(200);
		}catch(InterruptedException e){
			e.printStackTrace(); 
		}
		
		setMoney(m-minus);
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}
}

class Park extends Thread{
	public void run() {
		System.out.println("start save");
		SyncTest.myBank.saveMoney(3000);
		System.out.println("start money : "+ SyncTest.myBank.getMoney());
	}
}

class ParkWife extends Thread{
	public void run() {
		System.out.println("start minus");
		SyncTest.myBank.minusMoney(1000);
		System.out.println("start money : "+ SyncTest.myBank.getMoney());
	}
}

public class SyncTest {

	public static Bank myBank= new Bank();
	
	public static void main(String[] args) throws InterruptedException {
		
		Park p= new Park();
		p.start();
		
		Thread.sleep(200);
		ParkWife pw=new ParkWife();
		pw.start();
	}
	
}

방식2. synchronized 블럭방식


class Bank{
	private int money=10000;
	
	//saveMoney가 수행되는 동안 다른쓰레드가  Bank에 접근못하게함
	//Park이 실행되는 동안 ParkWife는 접근못함
	public synchronized void saveMoney(int save) {
		synchronized (this) {
			
			int m=this.getMoney();
			
			try {
				Thread.sleep(3000);
			}catch(InterruptedException e){
				e.printStackTrace(); 
			}
			
			setMoney(m+save);
			
		}
	}
	
 //생략
  • 만약에 쓰레드안에 동기화를 적용시키고 싶다면 run()에 synchronized를 주면 안되고 run메소드안에 synchronized를 블럭화시키면된다.
class Bank{
	private int money=10000;
	
	//saveMoney가 수행되는 동안 다른쓰레드가  Bank에 접근못하게함
	//Park이 실행되는 동안 ParkWife는 접근못함
	public void saveMoney(int save) {
			
			int m=this.getMoney();
			
			try {
				Thread.sleep(3000);
			}catch(InterruptedException e){
				e.printStackTrace(); 
			}
			
			setMoney(m+save);

	}
	
	public void minusMoney(int minus) {
		int m=this.getMoney();
		
		try {
			Thread.sleep(200);
		}catch(InterruptedException e){
			e.printStackTrace(); 
		}
		
		setMoney(m-minus);
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}
}

class Park extends Thread{
	public void run() {
		synchronized (SyncTest.myBank) {
			System.out.println("start save");
			SyncTest.myBank.saveMoney(3000);
			System.out.println("start money : "+ SyncTest.myBank.getMoney());
		}
		
	}
}

class ParkWife extends Thread{
	public void run() {
		synchronized (SyncTest.myBank) {
			System.out.println("start minus");
			SyncTest.myBank.minusMoney(1000);
			System.out.println("start money : "+ SyncTest.myBank.getMoney());
		}
		
	}
}

public class SyncTest {

	public static Bank myBank= new Bank();
	
	public static void main(String[] args) throws InterruptedException {
		
		Park p= new Park();
		p.start();
		
		Thread.sleep(200);
		ParkWife pw=new ParkWife();
		pw.start();
	}
	
}

deadlock

wait()/notify()

  • wait() : 리소스가 더이상 유효하지 않은 경우 리소스가 사용 가능할 때까지 위해 thread를 non-runnable상태로 전환, wait()상태가 된 thread은 notify()가 호출 될때까지 기다린다.
  • notify() : wait()하고 있는 thread 중 한 thread를 runnable한 상태로 깨움
  • notifyAll()
    - wait()하고 있는 모든 thread가 runnable한 상태가 되도록 함
    - notify()보다 notifyAll()을 사용하기를 권장
    - 특정 thread가 통지를 받도록 제어 할 수 없으므로 모두 깨운 후 scheduler에 CPU를 점유하는 것이 좀 더 공평하다고 함
class FastLibrary{
	public ArrayList<String> books=new ArrayList<String>();
	
	public FastLibrary() {
		books.add("태백산맥 1");
		books.add("태백산맥 2");
		books.add("태백산맥 3");

		
	}
	public synchronized String lendBook() throws InterruptedException {
		Thread t=Thread.currentThread();
		//책이 없으면 못빌리는 것으로 if문 null처리
		//if(books.size() == 0) return null;
		
		if(books.size() ==0) {
			System.out.println(t.getName() + "wating start");
			wait();
			System.out.println(t.getName() + "wating end");
		}
		
		
		String title=books.remove(0);
		System.out.println(t.getName()+ ":" + title + " lend");
		return title;
	}
	
	public synchronized void returnBook(String title) {
		Thread t=Thread.currentThread();
		books.add(title);
		notify();
		System.out.println(t.getName()+ ":" + title + " return");
	}
}

class Student extends Thread{
	public void run() {
		
		try {
			String title=LibraryMain.library.lendBook();
			if ( title == null) return;
			sleep(5000);
			LibraryMain.library.returnBook(title);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class LibraryMain {

	public static FastLibrary library=new FastLibrary();
	public static void main(String[] args) {
		
		Student std1=new Student();
		Student std2=new Student();
		Student std3=new Student();
		Student std4=new Student();
		Student std5=new Student();
		Student std6=new Student();
		
		std1.start();
		std2.start();
		std3.start();
		std4.start();
		std5.start();
		std6.start();
	}
}
profile
김주현
이전 포스트

[JAVA][패스트캠퍼스]자바 입출력 - 그 외 입출력 클래스와 데코레이터 패턴

다음 포스트

[패스트캠퍼스]스프링부트프로젝트-어드민페이지만들기-SpringBoot란

0개의 댓글

관련 채용 정보