[Java] 실습 (Thread)

package thread;

//----------------------------------------------------------------------
// class ShowThread extends Thread
//----------------------------------------------------------------------
class ShowThread extends Thread {
	
	String threadName; // 생성되는 쓰레드에 부여할 이름
	
	public ShowThread(String name) {
		threadName = name;
	}
	
	public void run() { // 쓰레드에서 클래스의 main()과 같은 역할의 메서드
		for(int i = 0; i < 100; i++) {
			System.out.println("안녕하세요? 저는 " + threadName + "입니다.");
			try {
				sleep(100); // 10분의 1초 동안 잠재운다. (1000이 1초)
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	
} // End - class ShowThread extends Thread

//----------------------------------------------------------------------
// public class ThreadUnderStand
//----------------------------------------------------------------------
public class ThreadUnderStand {

	public static void main(String[] args) {
		
		ShowThread st1 = new ShowThread("멋진 쓰레드");
		ShowThread st2 = new ShowThread("귀여운 쓰레드");
		ShowThread st3 = new ShowThread("이쁜 쓰레드");
		
		// 쓰레드를 구동 시킨다. (동시)
		st1.start();
		st2.start();
		st3.start();
		
		// run()을 직접 호출하면 일반 메서드를 호출한 것과 같다.
//		st1.run();
//		st2.run();
//		st3.run();

	}

} // End - public class ThreadUnderStand

실행 결과

 

package thread;

//----------------------------------------------------------------------
// class Sum
//----------------------------------------------------------------------
class Sum {
	int num;
	public Sum() { num = 0; }
	public void addNum(int n) { num += n; }
	public int getNum() { return num; }
} // End - class Sum
//----------------------------------------------------------------------
// Runnable 인터페이스를 상속해서 쓰레드를 만든다.
//----------------------------------------------------------------------
class AdderThread extends Sum implements Runnable {
	int start, end;
	
	public AdderThread(int s, int e) {
		start = s;
		end = e;
	}
	
	@Override
	public void run() {
		for(int i = start; i <= end; i++) {
			addNum(i);
		}
		
	}
		
} // End - class AdderThread extends Sum implements Runnable

//----------------------------------------------------------------------
// public class RunnableThread
//----------------------------------------------------------------------
public class RunnableThread {

	public static void main(String[] args) {
		
		AdderThread at1 = new AdderThread(1, 100);
		AdderThread at2 = new AdderThread(101, 200);
		Thread 		tr1 = new Thread(at1);
		Thread 		tr2 = new Thread(at2);
		tr1.start();
		tr2.start();
		
		try {
			// join() : 해당 쓰레드가 종료될 때까지 실행을 멈출 때 호출하는 메서드
			// tr1과 tr2가 참조하는 쓰레드가 종료되어야 아래의 합계를 출력하는 문장이 실행된다.
			tr1.join();
			tr2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("1 ~ 200까지의 합 : " + (at1.getNum() + at2.getNum()));

	} // End - public static void main(String[] args)

} // End - public class RunnableThread

실행 결과

 

package thread.priority01;

//----------------------------------------------------------------------
// class MessangeSendingThread extends Thread
//----------------------------------------------------------------------
class MessageSendingThread extends Thread {
	String message;
	int priority;
	
	public MessageSendingThread(String str) {
		message = str;
	}
	
	public void run() {
		for(int i = 0; i < 10000; i++) {
			System.out.println(message + "[" + getPriority() + "]");
		}
	}
	
} // End - class MessangeSendingThread extends Thread

//----------------------------------------------------------------------
// public class PriorityExamOne
//----------------------------------------------------------------------
public class PriorityExamOne {

	public static void main(String[] args) {
		
		MessageSendingThread tr1 = new MessageSendingThread("First");
		MessageSendingThread tr2 = new MessageSendingThread("Second");
		MessageSendingThread tr3 = new MessageSendingThread("Third");
		
		tr1.start();
		tr2.start();
		tr3.start();

	} // End - public static void main(String[] args)

} // End - public class PriorityExamOne

실행 결과

 

package thread.priority02;

//----------------------------------------------------------------------
//class MessangeSendingThread extends Thread
//----------------------------------------------------------------------
class MessageSendingThread extends Thread {
	String message;
	
	public MessageSendingThread(String str, int prio) {
		message = str;
		setPriority(prio);
	}
	
	public void run() {
		for(int i = 0; i < 10000; i++) {
			System.out.println(message + "[" + getPriority() + "]");
		}
	}
} // End - class MessageSendingThread extends Thread
//----------------------------------------------------------------------
// public class PriorityExamTwo
//----------------------------------------------------------------------
public class PriorityExamTwo {

	public static void main(String[] args) {
		
		MessageSendingThread tr1 = new MessageSendingThread("First", Thread.MAX_PRIORITY);
		MessageSendingThread tr2 = new MessageSendingThread("Second", Thread.NORM_PRIORITY);
		MessageSendingThread tr3 = new MessageSendingThread("Third", Thread.MIN_PRIORITY);
		
		tr1.start();
		tr2.start();
		tr3.start();

	}

} // End - public class PriorityExamTwo

실행 결과

 

package thread.priority03;

//----------------------------------------------------------------------
//class MessangeSendingThread extends Thread
//----------------------------------------------------------------------
class MessageSendingThread extends Thread {
	String message;
	
	public MessageSendingThread(String str, int prio) {
		message = str;
		setPriority(prio);
	}
	
	public void run() {
		for(int i = 0; i < 10000; i++) {
			System.out.println(message + "[" + getPriority() + "]");
			try {
				sleep(1); // 1초 == 1000
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
} // End - class MessageSendingThread extends Thread
//----------------------------------------------------------------------
//public class PriorityExamThree
//----------------------------------------------------------------------
public class PriorityExamThree {

	public static void main(String[] args) {
		
		MessageSendingThread tr1 = new MessageSendingThread("First", Thread.MAX_PRIORITY);
		MessageSendingThread tr2 = new MessageSendingThread("Second", Thread.NORM_PRIORITY);
		MessageSendingThread tr3 = new MessageSendingThread("Third", Thread.MIN_PRIORITY);
		
		tr1.start();
		tr2.start();
		tr3.start();

	}

} // End - public class PriorityExamThree

실행 결과

1.

package thread.haep.sync01;

//----------------------------------------------------------------------
// class Increment
//----------------------------------------------------------------------
class Increment {
	int num = 0;
	// 동기화를 하면 둘 이상의 쓰레드가 동시에 접근을 하지 못하므로 성능이 떨어질 수 밖에 없다.
	// public synchronized void increment() { num++; }
	public void increment() { num++; }
	public int getNum() { return num; }
} // End - class Increment

//----------------------------------------------------------------------
// class IncThread extends Thread
//----------------------------------------------------------------------
class IncThread extends Thread {
	Increment inc;
	
	public IncThread(Increment inc) {
		this.inc = inc;
	}
	
	public void run() {
		for(int i = 0; i < 10000; i++)
			for(int j = 0; j < 10000; j++)
				inc.increment();
	}
	
} // End - class IncThread extends Thread
//----------------------------------------------------------------------
// public class ThreadSyncErrorExam
//----------------------------------------------------------------------
public class ThreadSyncErrorExam {

	public static void main(String[] args) {
		
		Increment inc = new Increment();
		IncThread it1 = new IncThread(inc);
		IncThread it2 = new IncThread(inc);
		IncThread it3 = new IncThread(inc);
		
		it1.start();	it2.start();	it3.start();
		
		try {
			it1.join(); it2.join(); it3.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("합계 : " + inc.getNum());
		

	}

} // End - public class ThreadSyncErrorExam

실행 결과

실행 결과

실행 결과

2.

package thread.haep.sync02;

//----------------------------------------------------------------------
// class Calculator
//----------------------------------------------------------------------
class Calculator {
	
	int opCount = 0; // 연산된 횟수를 저장할 변수
	
	// public synchronized int plus(int num1, int num2) {
	public int plus(int num1, int num2) {
		synchronized(this) {
		opCount++; // 동기화가 필요한 부분
		}
		return num1 + num2;
	}
	
	// public synchronized int minus(int num1, int num2) {
	public int minus(int num1, int num2) {
		synchronized(this) {
		opCount++; // 동기화가 필요한 부분
		}
		return num1 - num2;
	}
	
	public void showOpCount() {
		System.out.println("총 연산 횟수 : " + opCount);
	}
	
} // End - class Calculator

//----------------------------------------------------------------------
// class PlusThread extends Thread
//----------------------------------------------------------------------
class PlusThread extends Thread {
	
	Calculator cal;
	
	public PlusThread(Calculator cal) {
		this.cal = cal;
	}
	
	public void run() {
		System.out.println("1 + 2 = " + cal.plus(1, 2));
		System.out.println("2 + 4 = " + cal.plus(2, 4));
	}
	
} // End - class PlusThread extends Thread

//----------------------------------------------------------------------
//class MinusThread extends Thread
//----------------------------------------------------------------------
class MinusThread extends Thread {
	
	Calculator cal;
	
	public MinusThread(Calculator cal) {
		this.cal = cal;
	}
	
	public void run() {
		System.out.println("2 - 1 = " + cal.minus(2, 1));
		System.out.println("4 - 2 = " + cal.minus(4, 2));
	}
	
} // End - class MinusThread extends Thread

//----------------------------------------------------------------------
// public class ThreadSyncMethodExam
//----------------------------------------------------------------------
public class ThreadSyncMethodExam {

	public static void main(String[] args) {
		
		Calculator cal = new Calculator();
		PlusThread pt = new PlusThread(cal);
		MinusThread mt = new MinusThread(cal);

		pt.start();
		mt.start();
		
		try {
			pt.join();
			mt.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		cal.showOpCount();
	}

} // End - public class ThreadSyncMethodExam

실행 결과

실행 결과

3.

package thread.haep;

//----------------------------------------------------------------------
// class Sum
//----------------------------------------------------------------------
class Sum {
	int num;
	public 			Sum() 			{ num = 0; }
	public void 	addNum(int n)	{ num += n; }
	public int 		getNum()		{ return num;}
} // End - class Sum

//----------------------------------------------------------------------
// class AdderThread extends Thread
//----------------------------------------------------------------------
class AdderThread extends Thread {
	Sum sumInst;
	int start, end;
	
	public AdderThread(Sum sum, int s, int e) {
		sumInst = sum;
		start = s;
		end = e;
	}
	
	public void run() {
		for(int i = start; i <= end; i++) {
			sumInst.addNum(i);
		}
	}
} // End - class AdderThread extends Thread
//----------------------------------------------------------------------
// public class ThreadHeapMultiAccessExam
//----------------------------------------------------------------------
public class ThreadHeapMultiAccessExam {

	public static void main(String[] args) {
		Sum s = new Sum();
		AdderThread at1 = new AdderThread(s, 1, 50);
		AdderThread at2 = new AdderThread(s, 51, 100);
		at1.start();
		at2.start();
		
		try {
			at1.join();
			at2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("1부터 100까지의 합은 " + s.getNum() + "입니다.");
	}
// 연산은 CPU를 이용한다.
} // End - public class ThreadHeapMultiAccessExam

실행 결과