JAVA 다중 for문 수행횟수에 따른 속도 차이 실험
JAVA 다중 for문 수행횟수에 따른 속도 차이 실험
책을 보는 중 횟수가 다른 다중 for문 중 반복 횟수가 작은 for문이 밖에 위치하는 것이 유리하다는 내용을 본적이 있다.
위 내용을 기반으로 한번 테스트 해보기로 했다.
실험할 for문이다.
첫번째 타입
|
1
2
3
4
5 |
for(int i=0; i<100; i++){
for(int j=0; j<100000000; j++){
tempNumber++;
}
} |
cs |
두번째 타입
|
1
2
3
4
5 |
for(int i=0; i<100000000; i++){
for(int j=0; j<100; j++){
tempNumber2++;
}
} |
cs |
이 두 for 문을 실행하고 그 시간을 측정해 보았다.
첫번째 타입 for문 4번, 두번째 타입 for문 4번
첫번째 타입 for문 4번, 두번째 타입 for문 4번
총 16번 실행했다.
결과는 다음과 같다.
|
FOR TYPE 1 FOR문 실행 시간 : 0.52
FOR TYPE 2 FOR문 실행 시간 : 0.79
FOR TYPE 1 FOR문 실행 시간 : 0.439
FOR TYPE 2 FOR문 실행 시간 : 0.75
|
첫번째 타입의 for문이 빨랐다.
밖의 for문과 안쪽의 for문의 반복횟수 차이가 1000000 배 ( 100000000 : 100 )가 날 경우에 약 2배의 실행시간 차이를 보였다.
시간은 0.03 초이지만 분명한 차이가 있었다.
이번에는 비율을 조금 바꾸어 보았다.
100000 배 ( 100000000 : 1000 )
|
FOR TYPE 1 FOR문 실행 시간 : 5.765
FOR TYPE 2 FOR문 실행 시간 : 6.993
FOR TYPE 1 FOR문 실행 시간 : 5.965
FOR TYPE 2 FOR문 실행 시간 : 6.971 |
이번에도 역시 약 2초차이정도로 첫번째 타입의 for문이 빨랐다.
이번에는 숫자를 줄이고 for문 안쪽에서 생성자를 생성해 보았다.
첫번째 타입
|
1
2
3
4
5
6 |
for(int i=0; i<100; i++){
for(int j=0; j<1000000; j++){
tempNumber++;
ForTest forTest = new ForTest();
}
} |
cs |
두번째 타입
|
1
2
3
4
5
6 |
for(int i=0; i<1000000; i++){
for(int j=0; j<100; j++){
tempNumber2++;
ForTest forTest = new ForTest();
}
} |
cs |
결과는 바뀌었다.
|
FOR TYPE 1 FOR문 실행 시간 : 0.189
FOR TYPE 2 FOR문 실행 시간 : 0.186
FOR TYPE 1 FOR문 실행 시간 : 0.222
FOR TYPE 2 FOR문 실행 시간 : 0.179
|
이번에는 두번째 타입의 for문이 0.04초가량 빨랐다.
머지 ?
마지막으로 for문 내부에서 List를 생성하고 그 List에 값을 넣어보았다.
첫번째 타입
|
1
2
3
4
5
6
7
8
9
10 |
for(int i=0; i<100; i++){
for(int j=0; j<1000000; j++){
tempNumber++;
List list = new ArrayList();
list.add(i);
list.add(i);
list.add(i);
list.add(i);
}
} |
cs |
두번째 타입
|
1
2
3
4
5
6
7
8
9
10 |
for(int i=0; i<1000000; i++){
for(int j=0; j<100; j++){
tempNumber2++;
List list = new ArrayList();
list.add(i);
list.add(i);
list.add(i);
list.add(i);
}
} |
cs |
결과는 다음과 같다.
|
FOR TYPE 1 FOR문 실행 시간 : 1.095
FOR TYPE 2 FOR문 실행 시간 : 2.574
FOR TYPE 1 FOR문 실행 시간 : 0.75
FOR TYPE 2 FOR문 실행 시간 : 2.285
|
첫번째 타입의 for문이 월등히 빨랐다.
그밖에도 여러 실험을 했지만 너무 큰 숫자는 속도가 너무 오래걸려 성격이 급한 나는 terminate 시켜버렸다.
결론
|
근데 왜 속도차이가 나는거지 ?
다중 for문의 실행 횟수가 10 : 10000 이라면
밖의 for문 1번, 내부 for문 10번으로 for문을 총 11번 호출하게 된다.
다중 for문의 실행 횟수가 10000 : 10 이라면
밖의 for문 1번, 내부 for문 10000번으로 for문을 총 10001번 호출하게 된다.
두 for문의 총 반복횟수는 100000번으로 같지만 for문을 호출하는 횟수가 차이가 난다.
여기에서 그 힌트가 있지 않을까 생각해본다.
작은 반복횟수에서는 의미가 없었다.
* 컬랙션, 배열 등의 로직을 하나씩 추가할 수록 그 차이가 심했다.
밖의 for문은 숫자가 작은놈으로...
|
전체소스
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62 |
public class ForTest {
long start = 0;
long end = 0;
long tempNumber = 0;
long tempNumber2 = 0;
public static void main(String[] args) {
ForTest forTest = new ForTest();
forTest.forType1();
forTest.forType1();
forTest.forType1();
forTest.forType1();
System.out.println();
forTest.forType2();
forTest.forType2();
forTest.forType2();
forTest.forType2();
System.out.println();
forTest.forType1();
forTest.forType1();
forTest.forType1();
forTest.forType1();
System.out.println();
forTest.forType2();
forTest.forType2();
forTest.forType2();
forTest.forType2();
System.out.println("temp : " + forTest.tempNumber);
System.out.println("temp2 : " + forTest.tempNumber2);
}
public void forType1(){
start = System.currentTimeMillis();
for(int i=0; i<100; i++){
for(int j=0; j<100000000; j++){
tempNumber++;
}
}
end = System.currentTimeMillis();
System.out.println( "FOR TYPE 1 FOR문 실행 시간 : " + ( end - start )/1000.0 );
}
public void forType2(){
start = System.currentTimeMillis();
for(int i=0; i<100000000; i++){
for(int j=0; j<100; j++){
tempNumber2++;
}
}
end = System.currentTimeMillis();
System.out.println( "FOR TYPE 2 FOR문 실행 시간 : " + ( end - start )/1000.0 );
}
} |
cs |