์๋ ํ์ธ์?
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ, ํน์ ์ฝ๋ฉ ํ ์คํธ๋ฅผ ๋ณด๋ค๊ฐ ์๋ค๋ ๋์ฒด ์ด๋ป๊ฒ ์๊ฐ์ ์ฌ๋ ๊ฑด์ง ๊ถ๊ธํ๋ ์ ์ด ์์์ด์.
์๋ ์๊ฐ ์ด๊ณผ๋ผ๋ ์๋ฒ CPU ๊ตฌ๋ ค์ ๊ทธ๋ฐ ๊ฑฐ ์๋์ผ? ๋ด ๋ก์ง์๋ ์๋ชป์ด ์๋ค!
๋ฐฉ๊ธ ์ฝํ ๋ณด๊ณ ํน๋ฐ์์ ์ฐ๋ ๊ธ ์๋๋๋ค.
์๋ฌดํผ ๊ณผ์ฐ ์ด๋ป๊ฒ ์๊ฐ์ ์ฌ๋ ๊ฑธ๊น์?
์ค๋์ Kotlin์์ ์ฝ๋์ ์คํ ์๊ฐ์ ์ด๋ป๊ฒ ์ธก์ ํ๋์ง์ ๋ํด ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
Java
์ ๊ฐ์๊ธฐ Java ๊บผ๋ด์ค๋๊ณ ์?
Java๋ Kotlin์ด๋ ์ด์ฐจํผ ๋ฐ์ดํธ์ฝ๋๋ก ๋ณํ๋์ด JVM์์ ๋์๊ฐ๋ ๊ฑด ๋๊ฐ๊ธฐ ๋๋ฌธ์ Kotlin์์ ํ๊ณ ์ ํ๋ ๊ฒ๋ค์ ๋๋ถ๋ถ Java์ ๋จผ์ ๊ตฌํ๋์ด ์๋ต๋๋ค.
Java์์ ์คํ ์๊ฐ์ ์ธก์ ํ๊ธฐ ์ํด์๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ธ ์ ์์ต๋๋ค.
1. System.currentTimeMillis()
์ด ํจ์๋ ํ์ฌ ์๊ฐ์ ms ๋จ์๋ก ๋ฆฌํดํด ์ค๋๋ค. ํ์ ์ Long์ด์์.
UTC ์๊ฐ์ธ 1970.01.01 ์์ ๋ถํฐ ํ์ฌ๊น์ง์ ์๊ฐ์ ms๋ก ๊ณ์ฐํด ์ฃผ๋๋ฐ์.
์ค…์ ๋ฒ ๋ง๋ง์น ์์ ์ซ์๊ฐ ๋์ค๊ฒ ์ฃ ? ํ์ง๋ง Long์ ๋ฌด์ ์ ๋๋ค.
ํ์ฌ ์๊ฐ 2023.02.11 15:58, ์ง๊ธ์ currnetTimeMillis()๋ฅผ ํ๋ฒ ์ฐ์ด๋ณผ๊ฒ์.
ms๋จ์๋ก ๊ณ์ฐํด ์ฃผ๊ธฐ ๋๋ฌธ์ ๋์ถฉ ๋ค์๊ณผ ๊ฐ์ด ๋์ต๋๋ค.
Long currentTime = System.currentTimeMillis();
System.out.print(currentTime);
// ๊ฒฐ๊ณผ
1676098695292
์ฝ๋ ์คํ ์๊ฐ์ ์ธก์ ํ๊ธฐ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ด ์์ฉํด ๋ณผ ์ ์๊ฒ ์ฃ .
Long startTime = System.currentTimeMillis();
// ์ฌ๋ฌ๋ถ์ ์ฝ๋...
Long endTime = System.currentTimeMillis();
System.out.print(endTime - startTime);
ms * 1000 ํ๋ฉด ์ด๋จ์๋ก ๊ฒฐ๊ณผ๊ฐ์ ์ ์ ์๊ฒ ์ต๋๋ค.
ํ์ง๋ง ์ด ๋ ๊ฒ ์ธก ์ ํ ์ง ๋ง ์ธ ์!
์ด ํจ์๊ฐ ms ๋จ์๋ก ๊ฒฐ๊ณผ๊ฐ์ ๊ณ์ฐํด ์ฃผ๊ธฐ๋ ํ์ง๋ง, ms๋งํผ์ ์ ํ์ฑ์ ๋ณด์ฅํ์ง๋ ์์ต๋๋ค.
๋ฐ์์ ๋ค์ ๋ณผ๊ฒ์.
2. System.nanoTime()
์ด ํจ์๋ currentTimeMillis()๋ณด๋ค ํจ์ฌ ์งง๋ค์. ํธ๊ฐ ํจ์์ ๋๋ค.
JVM์ ์๊ฐ์ ns ๋จ์๋ก ๋ฐํํ๋ ํจ์์ ๋๋ค. ์์คํ ์๊ฐ์ด๋ UTC ์๊ฐ๊ณผ ๋ฌด ๊ด ํฉ ๋ ๋ค !
๊ทธ๋ฌ๋ ์คํ ์๊ฐ์ ์์ฃผ์์ฃผ ์ ํํ ์ธก์ ํ ๋๋ง ์ฐ๋ ๊ฒ์ด ์ข๊ฒ ์ฃ ?
์์ ์๊ฐ์ ๋จ์๋ ๊ฒธ์ฌ๊ฒธ์ฌ ์์๋ด ์๋ค.
- ms - millisecond, 1/10^3 ์ด, ๋ฐ๋ฆฌ์ด
- ๊ฒ์ํ์๋ ๋ถ๋ค์ ์ต์ํ์ค ๊ฒ๋๋ค. ํ์ ๋จ์๋ก ์ฌ์ฉ๋๊ธฐ๋ ํฉ๋๋ค.
- ๋์คํฌ ์ก์ธ์ค ์๋์ ์ธํฐ๋ท ์๋(ํจํท์ด ์ด๋ํ๋ ์๋) ๋ฑ์ ์ธก์ ํ ๋ ์๋๋ค.
- μs - microsecond, 1/10^6, ๋ง์ดํฌ๋ก์ด
- ์์ ์์ํ๊ฒ ์๋๊ธฐ๊ฐ ํ๋ ๋ฐํ์๋๋ฐ u๊ฐ ๊นจ์ง ๊ฒ ์๋๋ผ ‘๋ฎค’๋ผ๊ณ ์ฝ๋ ๊ทธ๋ฆฌ์ค ๋ฌธ์์ ๋๋ค.
- μ๋ ์ฌ์ฉ์ด ๋๋ฌธ ๋ฌธ์๋ผ ํ์ค์ ์๋์ง๋ง ํธ์์ us๋ก ํ๊ธฐํ๊ธฐ๋ ํ๋ค๋ค์.
- ns - nanosecond, 1/10^9, ๋๋
ธ์ด
- RAM์ ์ก์ธ์ค ์๋๋ฅผ ์ธก์ ํ๋ ๋จ์๋ก ์ฌ์ฉ๋ฉ๋๋ค.
์ด ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์๊ฒ ์ต๋๋ค.
Long startTime = System.nanoTime();
// ์ฌ๋ฌ๋ถ์ ์ฝ๋...
Long endTime = System.nanoTime();
System.out.print(endTime - startTime);
์์ ์๊ฐ์ ๋จ์์์ ms์ ns ์ค๊ฐ์ ์์ํ ๋ง์ดํฌ๋ก์ด๊ฐ ์์์ง์?
๊ทธ๋์ ๊ฒฐ๊ณผ๊ฐ์ ์ฌ์ฏ ์นธ ๋ก๊ฒจ ์ฝ์ด์ผ ms๋ก ์ฝ์ ์ ์๋ต๋๋ค.
๊ทธ๋์ ๋ญ ์จ์ผ ํ ๊น์?
System.nanoTime() ์ฐ์ธ์.
ํธ๊ฐ ํจ์๋ผ์ ์ถ์ฒํ๋ ๊ฑฐ ์๋๋๋ค.
System.currentTimeMillis()๋ “ํ์ฌ ์๊ฐ”์ ๊ธฐ์ค์ผ๋ก ๊ฐ์ ๊ณ์ฐํ๊ฒ ๋ฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ์ป๊ณ ์ ํ๋ ๊ฒ์ “์ฝ๋์ ์คํ ์๊ฐ”์ด์ง, “์ฝ๋ ๋๋ ์๊ฐ - ์ฝ๋ ์์ํ ์๊ฐ” ์ด ์๋๊ฑฐ๋ ์.
๊ทธ๊ฒ ๊ทธ๊ฑฐ ์๋๊ฐ?
์๋๋๋ค.
์ด๋ฐ ๊ฐ๋ ์ wall clock time์ด๋ผ๊ณ ๋ ํฉ๋๋ค. ์๋์ ๋งํฌ์์ 2011๋ ์ ์ ์ง์๋ค์ ํ ๋ก ์ ์ฝ์ด๋ณด์ธ์.
What specifically are wall-clock-time, user-cpu-time, and system-cpu-time in Unix?
I can take a guess based on the names, but what specifically are wall-clock-time, user-cpu-time, and system-cpu-time in Unix? Is user-cpu time the amount of time spent executing user-code while ker...
stackoverflow.com
Kotlin
๋ณธ๋ก ์ ๋๋ค.
์์์ ์ฌ์ฉํ ํจ์๋ค๋ Kotlin์์ ์ฝ๋์ ์คํ ์๊ฐ์ ์ธก์ ํ๊ธฐ ์ํด ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค.
ํ์ง๋ง ์ฌ๋์ด ์ ๋ฌธ๋ฌผ์ ์ฐ๊ณ ์ด์์ผ๊ฒ ์ฃ ?
Kotlin์์๋ ์๊ฐ ์ธก์ ์ ๋ณด๋ค ๊ฐํธํ๊ฒ ํ ์ ์๋๋ก ๋ช ๊ฐ์ง ํจ์๋ฅผ ์ ๊ณตํฉ๋๋ค.
1. measureTimeMillis(block: () -> Unit): Long
System.currentTimeMillis()๋ณด๋ค ๊ธฐ๋ค์.
๋นํธ๊ฐ ํจ์์ ๋๋ค.
System.currentTimeMillis()์ ์งํ์ฒด์ ๋๋ค.
block ๋ด๋ถ ์ฝ๋์ ์คํ ์๊ฐ์ System.currentTimeMillis()๋ฅผ ์ด์ฉํด์ ์ธก์ ํ๊ณ , ๊ทธ ์๊ฐ์ Long ํ์์ผ๋ก ๋ฐํํฉ๋๋ค.
ํ์ง๋ง ์์์ ๋งํ์ฃ ?
์ฝ๋์ ์คํ ์๊ฐ์ ์ธก์ ํ ๋ System.currentTimeMillis()๋ฅผ ์ฐ๋ ๊ฑด ์ถ์ฒํ์ง ์์ต๋๋ค.
์ด๊ฑฐ ์จ์ ์๊ฐ ์๋๋ฐ ์ ์๊ฐ์ด ์ด์ํ๋๋ ์ง๋ฌธ์ ์ฌ์ฉ์ ์ด์์ ๋๋ค.
val measuredTime = measureTimeMillis {
// ์ฌ๋ฌ๋ถ์ ํจ์...์ฝ๋...์๊ฐ ์ธก์ ์ด ํ์ํ ๋ด์ฉ
}
print(measuredTime)
2. measureNanoTime(block: () -> Unit): Long
๋ญ๊ฐ ์ต์ํ์ฃ ?
๋ง์ต๋๋ค.
์๋ System.nanoTime()์ ์งํ์ฒด์ ๋๋ค.
block ๋ด๋ถ ์ฝ๋์ ์คํ ์๊ฐ์ System.nanoTime()๋ฅผ ์ด์ฉํด์ ์ธก์ ํ๊ณ , ๊ทธ ์๊ฐ์ Long ํ์์ผ๋ก ๋ฐํํฉ๋๋ค.
์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ์ ์ํด solution() ํจ์๋ฅผ ์ฌ์ฉํ์ ๋ค๋ ๊ฐ ํด์ ์ฝ๋๋ฅผ ๊น๋ํ๊ฒ ์ชผ๊ฐ๋์ผ์ ๋ถ์ ์ด๋ ๊ฒ ์ธก์ ํ๋ ๊ฒ์ด ๋ ํธํ๊ฒ ์ง์?
๋ง๊ตฌ์ก์ด๋ก ์ง์ ๋ถ์ reusability์ ํ์ ํ๋ฒ ๋๊ปด๋ณด๋๋ก ํ์ธ์. (๋น์ฌ์์ฑ ๋ฐ์ธ์ ๋๋ค)
val measuredTime = measureNanoTime {
// ์ฌ๋ฌ๋ถ์ ํจ์...์ฝ๋...์๊ฐ ์ธก์ ์ด ํ์ํ ๋ด์ฉ
}
print(measuredTime)
3. measureTimedValue(block: () -> T): TimedValue
์ฝ๋๋ฅผ ๋จผ์ ํ๋ฒ ๋ณผ๊น์?
val measuredTime = measureTimedValue {
// ์ฌ๋ฌ๋ถ์ ํจ์...์ฝ๋...์๊ฐ ์ธก์ ์ด ํ์ํ ๋ด์ฉ
}
print(measuredTime)
์ด ํจ์๋ TimedValue๋ผ๋ ํด๋์ค๋ก block ๋ด๋ถ ์ฝ๋์ ์คํ ์๊ฐ์ ๋ฆฌํดํด์ฃผ๋ ๋ด ๋๋ค…
์ฅ ๋๊ตฌ์ธ์?
๊ตฌ๊ธ๋งํ๊ณผ ์กธ์ ์์ ์๋ก์ ์ ๋ง ๋นํฉ์ค๋ฐ ์ผ์ ๊ฒช์์ต๋๋ค…
Kotlin TimedValue์ ๋ํด ๊ฒ์ํด ๋ณด๋ ์๋ฌด๊ฒ๋ ๋์ค์ง ์์์ด์. ์ง์ง ๋๊ตฌ์ธ์?
๋ฌผ๋ก measuredTimedValue๋ผ๋ ํจ์์ ๋ํ ๊ฒ์๊ธ์ ๋ช ๊ฐ ์์๋๋ฐ์.
TimedValue๊ฐ ๋์ ์ง์ ๋ํด์๋ ์๋ฌด๋ ํ๊ตญ์ด๋ก ์ค๋ช ํด ์ฃผ์ง ์์ผ์ จ์ต๋๋ค. ํ...
์ฝํ๋ฆฐ์ด ์ด๋ ค์ ๊ทธ๋ฐ๊ฐ ๋ด ๋๋ค.
๊ณต์ ๋ฌธ์๋ผ๋ ๊ฒ ์์ด์ ์ ๋ง ๋คํ์ด์์. ์๋๋ TimedValue์ ๊ณต์ ๋ฌธ์์ ๋๋ค.
TimedValue - Kotlin Programming Language
kotlinlang.org
Data class representing a result of executing an action, along with the duration of elapsed time interval.
๋ฐ์ดํฐ ํด๋์ค์ ๋๋ค. ํด๋์ค ๋ณ์๋ก action ์คํ ๊ฒฐ๊ณผ์ ๊ทธ ์คํ ์๊ฐ์ Duration ํ์ ์ผ๋ก ๊ฐ์ง๋ค์.
์ด measureTimedValue๋ผ๋ ํจ์๋ block์ ์๊ตฌํ๊ณ , ์ด block์ ๋ฆฌํดํ์ ์ด ์กด์ฌํฉ๋๋ค. ์ฆ, ์ด block์์ action์ ํตํด ์ด๋ค ๊ฐ์ ๋ฐ์ ์ ์์ต๋๋ค. ๋ฌผ๋ก ๋ฆฌํด ์ฌ๋ถ๋ ์ ํ์ด๋ฏ๋ก ๋ฆฌํดํ์ง ์์ ์๋ ์๊ณ ์.
์ฐธ๊ณ ๋ก ์์ 1๋ฒ, 2๋ฒ์ block: () → Unit์ ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์๋๋ฐ, ์ด๋ ๋ฆฌํดํ๋ ๊ฒ์ด ์๋ block์ ์๋ฏธํฉ๋๋ค.
์ฌ์ฉ ์์๋ฅผ ๋ค์ ํ ๋ฒ ๋ณด๊ฒ ์ต๋๋ค.
val measuredTime = measureTimedValue {
var A = 12
var B = 34
return@measureTimedValue A + B
// return@measureTimedValue๋ ์๋ตํด๋ ๋ฉ๋๋ค
// A + B <- ์ด๋ฐ ์์ผ๋ก...
}
print(measuredTime)
//๊ฒฐ๊ณผ
TimedValue(value=46, duration=12.9us)
A+B์ ๊ฐ์ด value์ ๋ค์ด๊ฐ ๊ฒ ๋ณด์ด์์ฃ ?
main()์ ๋ฆฌํดํ๋ ๊ฒ์ด ์๋๊ธฐ ๋๋ฌธ์ A+B๊ฐ measureTimedValue์ ๋ฆฌํด๊ฐ์ด๋ผ๋ ๊ฒ์ ๋ช ์ํด ์ฃผ์์ต๋๋ค.
4. measureTime(block: () -> Unit): Duration
์ด ํจ์๋ TimeValue๊ฐ ์๋๋ผ Duration์ด๋ผ๋ ํ์ ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํดํด ์ค๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ธ ์ ์์ด์.
val measuredTime = measureTime {
// ์ฌ๋ฌ๋ถ์ ์ฝ๋...
}
print(measuredTime)
// ์์ ๊ฒฐ๊ณผ: measureTime block์ ์๋ฌด๊ฒ๋ ์์ฑํ์ง ์์์ ๋
10.9us
์ถ๋ ฅ ํ์์ด ์๋นํ ๋ง์กฑ์ค๋ฝ์ต๋๋ค. ๋ฑํ ๋ญ ํ ๊ฑฐ ์๋๋ฐ ์ ๋นํ ๋จ์๋ก ์๋์ผ๋ก ๋ณํํด์ ์ถ๋ ฅํด ์ฃผ๋ค์.
์ด๊ฑด ์ฌ์ค Duration์ด ํ์จ์ค ๊ฒฐ๊ณผ๋๋๋ค.
5. Duration?
์ด ์น๊ตฌ๋ Kotlin 1.3์์ Experimental๋ก ์ถ๊ฐ๋ ํด๋์ค์ ๋๋ค.
๋ฌด์จ ๋ง์ด๋๋ฉด ์๋ฆฌ์๋ฌธ ์์ด ์ฌ๋ผ์ง ์๋ ์๊ณ ์์ง ๊ฐ์งํ์ง ๋ชปํ ์น๋ช ์ ์ธ ๋ฒ๊ทธ๋ ์์ ์ ์๋ค๋ ๋ป์ด์ฃ …
๊ทธ๋ผ ์ฐ๋ฉด ์ ๋๋ ๊ฑฐ ์๋๊ฐ์?
๋คํํ๋ Kotlin 1.6์์ Stable๋ก promote๋์๋ต๋๋ค. ์ถํํด์~
What's new in Kotlin 1.6.0 | Kotlin
kotlinlang.org
Java์์๋ ๊ณต์ time API ์ค Date์๋๊ฐ? ๊ฐ ์ฌ์ฉ์ฑ์ด ์์ฒญ ๋ณ๋ก์๋ ๊ฒ ๊ฐ์๋ฐ Kotlin์ ์ด๋ค์ง ์ ๋ชจ๋ฅด๊ฒ ๋ค์.
์ด๊ฒ์ ๊ฒ ๋ง์ ธ๋ดค๋๋ฐ ์ ๋ ๋ง์กฑ์ค๋ฝ๊ฒ ์ธ ๊ฒ ๊ฐ์ต๋๋ค.
๋ช ๊ฐ์ง ์ข์๋ ์ ์ ์๊ฐํด ๋๋ฆด๊ฒ์.
- toString()์ ํ๋ฉด ์ฌ๋์ด ์ฝ๊ธฐ ํธํ ๋จ์๋ก ์๋์ผ๋ก ์ถ๋ ฅํด ์ค๋๋ค.
- ๋ณํ ์์ ๋ก์(Ex. ๋ฐ๋ฆฌ์ด to ๋๋ ธ์ด, ๋ฐ๋ฆฌ์ด to ์ผ์)
์์๋ฅผ ๋ณผ๊ฒ์.
var test = 1397239847.toDuration(DurationUnit.MILLISECONDS)
println(test)
println(test.inWholeHours)
// ๊ฒฐ๊ณผ
16d 4h 7m 19.847s
388
์ด๊ฒ ์ฝ๋์ ์ ๋ถ์ ๋๋ค. ์งฑ์ด์ฃ ?
1397239847 ๋ฐ๋ฆฌ์ด๋ฅผ println์ผ๋ก ์ถ๋ ฅํ๋ฉด ๋ฐ๋ก day, hour, min ๋ฑ์ผ๋ก ์ ๋๋ ์ ์ฌ๋์ด ์ฝ๊ธฐ ์ข๊ฒ ๋ณํํด ์ค๋๋ค.
์ผ ์๋ก ๋ณํํ๋ฉด ๋ฉฐ์น ์ธ์ง๋ ๋ฐ๋ก ์๋ ค์ค์.
test.inWholeHours.toInt()๋ฅผ ํ๋ฉด Int์๋ ์ ์ฅํ ์ ์๋ต๋๋ค.
๊ฒฐ๋ก
์ฌ์ค ์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ์๊ฐ ์ด๊ณผ ๋ฌธ์ ๋ ๋ก์ง์ ์๋ชป ์งฐ๊ฑฐ๋ ์ค์ํ ๊ฒฝ์ฐ๊ฐ ๋ง์์ต๋๋ค.
๊ทธ๋์ ์ด๊ฑฐ ๊ตณ์ด ์ฐ์ด๋ณด๋ ๊ฑด ์ข ์ฝ์ง์ด์์.
ํ์ง๋ง ์ฌ๋์ด ์ฝ์ง ์ข ํด๋ด์ผ ํํ๋ ๊ธธ๋ฌ์ง๊ณ ๊ทธ๋ฌ์ง ์๊ฒ ์ต๋๊น?
๊ถ๊ธํ์ ๋ถ์ ์ฐ์ด๋ณด์ธ์.
์ฐ์ ๊ฑฐ๋ฉด nanoTime๋ฅ์ ํจ์๋ฅผ ์ฐ์๊ณ , ํ ์ผ ํผ์ง๋งํ๊ฒ ๋ช์ญ๊ฐ์ฉ ๋ฃ์ด๋ณด๊ฒ ๋ค ํ์๋ ๋ถ๋ค์ ๋ชจ๋ํํ์ ์ Duration์ ์ ์ ํ๊ฒ ์ฌ์ฉํ์๋ ๊ฒ์ด ์ข๊ฒ ์ต๋๋ค.
'๐ ๊ณต๋ถ > ๐ Kotlin' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Kotlin์์ Set์ Array ๋ฃ๋ ๋ฐฉ๋ฒ (0) | 2023.07.19 |
---|---|
Kotlin์ Equality, == vs === (1) | 2023.04.27 |
์ฝํ๋ฆฐ ๋๋ฌด ์ฌ๋ฐ๋ค๋ ๊ธ (0) | 2023.04.24 |