[JAVA] 하나의 스레드와 여러 개의 스레드가 수행되는 시간 비교하기

🌳 스레드가 수행되는 시간 확인해보기

1. Runnable 인터페이스를 구현한 class를 작성한다.

class SumRunner implements Runnable {
	@Override
	public void run() {
		long sum = 0L;
		for (long i = 1L; i < 1_000_000_000L; i++) {
			sum += i;
		}
		System.out.println("합계 : " + sum);
	}

2. 메인 메소드를 작성한다.

   - join() 메소드를 이용한다.

     join() 메소드란?

      현재 실행중인 스레드에서 대상이 되는 스레드(변수 th)가

      종료될 때까지 기다리는 메소드

public class ThreadTest03 {

	public static void main(String[] args) {
		// 스레드가 수행되는 시간 확인해보기
		Thread th = new Thread(new SumRunner());

		// 1970년 1월 1일 0시 0분 0초(표준시간)부터
		// 현재까지 경과한 시간을 밀리세컨드(1/1000) 단위로 반환한다.
		long startTime = System.currentTimeMillis();

		th.start();

		try {
			th.join();
		} catch (InterruptedException e) {

		}

		long endTime = System.currentTimeMillis();

		System.out.println("경과 시간 : " + (endTime - startTime));

	}
    
    // 실행 결과
	// 합계 : 499999999500000000
	// 경과 시간 : 239

경과 시간이 239이므로 스레드가 수행되는 시간이 약 0.24초 걸렸다는 것을 알 수 있다.

 

 

🌳 1 ~ 20억까지의 합계를 구하는 프로그램을 하나의 스레드가 단독으로 처리했을 때와

여러 개의 스레드가 협력하여 처리할 때의 경과시간을 비교해보자.

public class ThreadTest04 {

	public static void main(String[] args) {
		// 단독으로 처리하기
		SumThread sumTh = new SumThread(1, 2_000_000_000L);

		long startTime = System.currentTimeMillis();
		sumTh.start();
		try {
			sumTh.join();
		} catch (InterruptedException e) {

		}
		long endTime = System.currentTimeMillis();

		System.out.println("단독으로 처리했을 때의 경과시간 : " + (endTime - startTime));
		System.out.println("-------------------------------------------------");

		// 여러 스레드가 협력해서 처리하기
		SumThread[] sumArr = new SumThread[] {
				new SumThread(1L, 500_000_000L),
				new SumThread(500_000_001L, 1_000_000_000L),
				new SumThread(1_000_000_001L, 1_500_000_000L),
				new SumThread(1_500_000_001L, 2_000_000_000L) };

		startTime = System.currentTimeMillis();
		for (SumThread smth : sumArr) {
			smth.start();
		}

		// 네 개의 스레드가 끝날 때까지 기다리게 한다.
		for (int i = 0; i < sumArr.length; i++) {
			try {
				sumArr[i].join();
			} catch (InterruptedException e) {

			}
		}

		endTime = System.currentTimeMillis();

		System.out.println("협력해서 처리했을 때의 경과시간 : " + (endTime - startTime));
	}

}

// 합계를 구하는 스레드
class SumThread extends Thread {
	// 합계를 구할 영역의 시작값과 종료값이 저장될 변수 선언
	private long startNum, endNum;

	// 생성자에서 시작값과 종료값
	public SumThread(long startNum, long endNum) {
		this.startNum = startNum;
		this.endNum = endNum;
	}

	@Override
	public void run() {
		long sum = 0L;
		for (long i = startNum; i <= endNum; i++) {
			sum += i;
		}
		System.out.println(startNum + "부터 " + endNum + "까지의 합계 : " + sum);
	}
}

// 실행 결과
// 1부터 2000000000까지의 합계 : 2000000001000000000
// 단독으로 처리했을 때의 경과시간 : 589
// ----------------------------------------------------------
// 1000000001부터 1500000000까지의 합계 : 625000000250000000
// 1부터 500000000까지의 합계 : 125000000250000000
// 1500000001부터 2000000000까지의 합계 : 875000000250000000
// 500000001부터 1000000000까지의 합계 : 375000000250000000
// 협력해서 처리했을 때의 경과시간 : 116