Ver3.0 ๐ iOS ์ฑ๋ฅ ์ต์ ํ์ Instruments๋ฅผ ํ์ฉํ ํ๋กํ์ผ๋ง ์๋ฒฝ ๊ฐ์ด๋

๐ iOS ์ฑ๋ฅ ์ต์ ํ์ Instruments๋ฅผ ํ์ฉํ ํ๋กํ์ผ๋ง ์๋ฒฝ ๊ฐ์ด๋
์ฑ์ ๋ ๋ ตํ๊ฒ ๋ง๋๋ ๋ง๋ฒ, ์ง๊ธ๋ถํฐ ์์ํฉ๋๋ค!
๐ฏ ์ฌ๋ฌ๋ถ, ํน์ ์ด๋ฐ ๊ฒฝํ ์์ผ์ ๊ฐ์?
์ด์ฌํ ๋ง๋ iOS ์ฑ์ธ๋ฐ ์ฌ์ฉ์๋ค์ด "์ฑ์ด ๋๋ ค์", "๋ฐฐํฐ๋ฆฌ๊ฐ ๊ธ๋ฐฉ ๋ณ์์", "์ฑ์ด ๋จ๊ฑฐ์์"๋ผ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋จ๊ธฐ๋ ์ํฉ ๋ง์ด์์. ๐ฐ
๊ฐ๋ฐ์๋ก์ ์ ๋ง ์์ํ ์๊ฐ์ด์ฃ . ํ์ง๋ง ๊ฑฑ์ ๋ง์ธ์! ์ค๋ ์ฐ๋ฆฌ๊ฐ ํจ๊ป ์์๋ณผ Instruments๋ผ๋ ๊ฐ๋ ฅํ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ฉด, ์ฌ๋ฌ๋ถ์ ์ฑ์ F1 ๋ ์ด์ฑ์นด์ฒ๋ผ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ๋ก ๋ง๋ค ์ ์๋ต๋๋ค. ๐๏ธ๐จ
์ด ๊ธ์์๋ iOS ์ฑ๋ฅ ์ต์ ํ์ ํต์ฌ ๊ฐ๋
๋ถํฐ ์ค์ ํ๋กํ์ผ๋ง ๊ธฐ๋ฒ๊น์ง, ์น๊ตฌ์๊ฒ ์ค๋ช
ํ๋ฏ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ์๋ ค๋๋ฆด๊ฒ์!
๐ฑ iOS ์ฑ๋ฅ ์ต์ ํ, ์ ์ค์ํ ๊น์?
์, ๋จผ์ ๊ทผ๋ณธ์ ์ธ ์ง๋ฌธ๋ถํฐ ์์ํด๋ณผ๊น์? ์ฑ๋ฅ ์ต์ ํ๊ฐ ์ ์ด๋ ๊ฒ ์ค์ํ ๊ฑธ๊น์?
์ฌ์ค ๋ต์ ๊ฐ๋จํด์. ์ฌ์ฉ์ ๊ฒฝํ(UX)์ด ๊ณง ์ฑ์ ์ฑ๊ณต์ ๊ฒฐ์ ํ๊ธฐ ๋๋ฌธ์ด์ฃ . ๐ช
์ฐ๊ตฌ์ ๋ฐ๋ฅด๋ฉด ์ฑ ๋ก๋ฉ ์๊ฐ์ด 1์ด ๋์ด๋ ๋๋ง๋ค ์ฌ์ฉ์ ์ดํ๋ฅ ์ด ์ฝ 7% ์ฆ๊ฐํ๋ค๊ณ ํด์. ๋ํ ๋ฐฐํฐ๋ฆฌ๋ฅผ ๊ณผ๋ํ๊ฒ ์๋ชจํ๋ ์ฑ์ ์ฌ์ฉ์๋ค์ด ๊ฐ์ฐจ ์์ด ์ญ์ ํด๋ฒ๋ฆฌ์ฃ . ๐
๐ก ์ฑ๋ฅ ์ต์ ํ๊ฐ ๊ฐ์ ธ๋ค์ฃผ๋ ์ค์ง์ ์ด์ ๋ค:
โ
์ฌ์ฉ์ ๋ง์กฑ๋ ํฅ์ - ๋น ๋ฅด๊ณ ๋ถ๋๋ฌ์ด ์ฑ์ ์ฌ์ฉ์๋ฅผ ํ๋ณตํ๊ฒ ๋ง๋ค์ด์
โ
์ฑ์คํ ์ด ํ์ ์์น - ์ข์ ์ฑ๋ฅ์ ์ข์ ๋ฆฌ๋ทฐ๋ก ์ด์ด์ ธ์
โ
๋ฐฐํฐ๋ฆฌ ์๋ช
์ฐ์ฅ - ํจ์จ์ ์ธ ์ฑ์ ๋๋ฐ์ด์ค๋ฅผ ์ค๋ ์ฌ์ฉํ๊ฒ ํด์ค์
โ
๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ - ํฌ๋์ ์๋ ์์ ์ ์ธ ์ฑ์ ๋ง๋ค ์ ์์ด์
โ
๋คํธ์ํฌ ๋น์ฉ ์ ๊ฐ - ๋ฐ์ดํฐ ์ฌ์ฉ๋์ ์ค์ฌ ์ฌ์ฉ์ ๋ถ๋ด์ ๋์ด์ค์
ํนํ ์์ฆ์ฒ๋ผ ๊ฒฝ์์ด ์น์ดํ ์ฑ ์์ฅ์์๋ ์ฑ๋ฅ์ด ๊ณง ๊ฒฝ์๋ ฅ์ด์์. ๊ฐ์ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ๋ ์ฑ์ด ์๋ค๋ฉด, ์ฌ์ฉ์๋ค์ ๋น์ฐํ ๋ ๋น ๋ฅด๊ณ ๋ถ๋๋ฌ์ด ์ฑ์ ์ ํํ๊ฒ ์ฃ ? ๐
๐ Instruments๋ ๋ฌด์์ธ๊ฐ์?
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฐ๋ฆฌ์ ์ฃผ์ธ๊ณต Instruments๋ฅผ ์๊ฐํ ๊ฒ์! ๐บ
Instruments๋ Apple์ด Xcode์ ํจ๊ป ์ ๊ณตํ๋ ์ฑ๋ฅ ๋ถ์ ๋ฐ ํ๋กํ์ผ๋ง ๋๊ตฌ์์. ์ฝ๊ฒ ๋งํ๋ฉด ์ฑ์ ๊ฑด๊ฐ๊ฒ์ง์ ํด์ฃผ๋ ์์ฌ ๊ฐ์ ์กด์ฌ์ฃ . ๐จโโ๏ธ
์ฌ๋ฌ๋ถ์ ์ฑ์ด ์ด๋์ ์๊ฐ์ ๋ง์ด ์ฐ๋์ง, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ผ๋ง๋ ์ฌ์ฉํ๋์ง, CPU๋ฅผ ์ผ๋ง๋ ํน์ฌ์ํค๋์ง ๋ฑ์ ์ค์๊ฐ์ผ๋ก ๋ณด์ฌ์ฃผ๊ณ ๋ถ์ํด์ค์.
๐ฏ Instruments์ ํต์ฌ ๊ธฐ๋ฅ๋ค
1. Time Profiler โฑ๏ธ
CPU ์ฌ์ฉ๋์ ์ถ์ ํ๊ณ ์ด๋ค ํจ์๊ฐ ๊ฐ์ฅ ๋ง์ ์๊ฐ์ ์๋นํ๋์ง ๋ณด์ฌ์ค์. ๋ง์น ์ฑ์ ์๊ฐํ๋ฅผ ์์ฑํด์ฃผ๋ ๊ฑฐ์ฃ !
2. Allocations ๐พ
๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ณผ ํด์ ๋ฅผ ์ถ์ ํด์. ๋ฉ๋ชจ๋ฆฌ ๋์(Memory Leak)๋ฅผ ์ฐพ์๋ด๋ ํ์ ๊ฐ์ ์ญํ ์ด์ฃ .
3. Leaks ๐
๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ์๋์ผ๋ก ๊ฐ์งํด์ค์. ์ฑ์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ก์๋จน๊ณ ๋์์ฃผ์ง ์๋ ๋ถ๋ถ์ ์ฐพ์๋ด์.
4. Energy Log ๐
๋ฐฐํฐ๋ฆฌ ์๋ชจ๋์ ๋ถ์ํด์. ์ด๋ค ์์
์ด ๋ฐฐํฐ๋ฆฌ๋ฅผ ๋ง์ด ์ฐ๋์ง ์๋ ค์ค์.
5. Network ๐
๋คํธ์ํฌ ์์ฒญ๊ณผ ์๋ต์ ๋ชจ๋ํฐ๋งํด์. API ํธ์ถ์ด ์ผ๋ง๋ ํจ์จ์ ์ธ์ง ํ์ธํ ์ ์์ด์.
6. Core Animation ๐จ
UI ๋ ๋๋ง ์ฑ๋ฅ์ ๋ถ์ํด์. ํ๋ฉด์ด ๋ถ๋๋ฝ๊ฒ ๊ทธ๋ ค์ง๋์ง ํ์ธํ ์ ์์ฃ .
Instruments๋ฅผ ์คํํ๋ ๋ฐฉ๋ฒ์ ์ ๋ง ๊ฐ๋จํด์:
๋ฐฉ๋ฒ 1: Xcode์์ Product โ Profile (โ + I) ์ ํ
๋ฐฉ๋ฒ 2: Applications ํด๋์์ ์ง์ Instruments ์ฑ ์คํ
์ฒ์ ์คํํ๋ฉด ๋ค์ํ ํ
ํ๋ฆฟ๋ค์ด ๋ํ๋๋๋ฐ, ๊ฐ๊ฐ์ ํ
ํ๋ฆฟ์ ํน์ ์ฑ๋ฅ ์งํ๋ฅผ ๋ถ์ํ๋ ๋ฐ ์ต์ ํ๋์ด ์์ด์. ๐
โก CPU ์ฑ๋ฅ ์ต์ ํ: Time Profiler ํ์ฉํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ค์ ์ ๋ค์ด๊ฐ๋ณผ๊น์? ์ฒซ ๋ฒ์งธ๋ก ์์๋ณผ ๊ฒ์ CPU ์ฑ๋ฅ ์ต์ ํ์์! ๐ฎ
CPU๋ ์ฑ์ ๋๋๋ผ๊ณ ํ ์ ์์ด์. ๋๋๊ฐ ๊ณผ๋ถํ๋๋ฉด ์ฑ์ด ๋๋ ค์ง๊ณ , ๋ฐฐํฐ๋ฆฌ๋ ๋นจ๋ฆฌ ๋ณ๊ณ , ๋๋ฐ์ด์ค๊ฐ ๋จ๊ฑฐ์์ง์ฃ . Time Profiler๋ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ์ต๊ณ ์ ๋๊ตฌ๋๋๋ค.
๐ฏ Time Profiler ์ฌ์ฉ ์์ํ๊ธฐ
Step 1: Xcode์์ โ + I๋ฅผ ๋๋ฌ Instruments๋ฅผ ์คํํด์
Step 2: ํ
ํ๋ฆฟ ๋ชฉ๋ก์์ "Time Profiler"๋ฅผ ์ ํํด์
Step 3: ๋นจ๊ฐ ๋
นํ ๋ฒํผ์ ๋๋ฌ ํ๋กํ์ผ๋ง์ ์์ํด์
Step 4: ์ฑ์์ ์ฑ๋ฅ ๋ฌธ์ ๊ฐ ์์ฌ๋๋ ๊ธฐ๋ฅ์ ์คํํด์
Step 5: ์ถฉ๋ถํ ๋ฐ์ดํฐ๊ฐ ์์ง๋๋ฉด ์ ์ง ๋ฒํผ์ ๋๋ฌ์
Time Profiler๋ฅผ ์คํํ๋ฉด ํ๋ฉด์ Call Tree๊ฐ ๋ํ๋์. ์ด๊ฑด ํจ์ ํธ์ถ ๊ด๊ณ๋ฅผ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ๋ณด์ฌ์ฃผ๋ ๊ฑด๋ฐ, ์ด๋ค ํจ์๊ฐ ์ผ๋ง๋ ๋ง์ CPU ์๊ฐ์ ์ฌ์ฉํ๋์ง ํ๋์ ๋ณผ ์ ์์ด์. ๐
์ฌ๊ธฐ์ ์ค์ํ ํ! Call Tree ํ๋จ์ ์ต์
๋ค์ ์ ํ์ฉํ๋ฉด ๋ถ์์ด ํจ์ฌ ์ฌ์์ ธ์:
๐ง Call Tree ํํฐ ์ต์
ํ์ฉํ๊ธฐ
โ Separate by Thread
์ค๋ ๋๋ณ๋ก ๋ถ๋ฆฌํด์ ๋ณด์ฌ์ค์. ๋ฉ์ธ ์ค๋ ๋์์ ๋ฌด๊ฑฐ์ด ์์
์ด ์คํ๋๊ณ ์๋์ง ํ์ธํ ๋ ์ ์ฉํด์!
โ Invert Call Tree
ํธ์ถ ํธ๋ฆฌ๋ฅผ ์ญ์์ผ๋ก ๋ณด์ฌ์ค์. ์ค์ ๋ก ์๊ฐ์ ๋ง์ด ์ด ํจ์๊ฐ ๋งจ ์์ ๋ํ๋์ ๋ฌธ์ ๋ฅผ ๋น ๋ฅด๊ฒ ์ฐพ์ ์ ์์ด์.
โ Hide System Libraries
์์คํ
๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์จ๊ฒจ์ ์ฌ๋ฌ๋ถ์ด ์์ฑํ ์ฝ๋๋ง ์ง์คํด์ ๋ณผ ์ ์์ด์.
โ Flatten Recursion
์ฌ๊ท ํธ์ถ์ ํํํํด์ ๋ณด์ฌ์ค์. ์ฌ๊ท ํจ์์ ์ฑ๋ฅ์ ๋ถ์ํ ๋ ํ์์์!
์ค์ ์ฌ๋ก๋ฅผ ํ๋ ๋ค์ด๋ณผ๊ฒ์. ์ ๊ฐ ์์ ์ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ์ฑ์ ๋ง๋ค ๋ ์์๋ ์ผ์ด์์. ๐ธ
์ฌ์ฉ์๊ฐ ํํฐ๋ฅผ ์ ์ฉํ๋ฉด ์ฑ์ด ๋ช ์ด์ฉ ๋ฉ์ถ๋ ๋ฌธ์ ๊ฐ ์์์ด์. Time Profiler๋ก ๋ถ์ํด๋ณด๋, ์ด๋ฏธ์ง ์ฒ๋ฆฌ ํจ์๊ฐ ๋ฉ์ธ ์ค๋ ๋์์ ์คํ๋๊ณ ์๋๋ผ๊ณ ์! ๐ฑ
ํด๊ฒฐ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ์ด์. ๋ฌด๊ฑฐ์ด ์ด๋ฏธ์ง ์ฒ๋ฆฌ ์์
์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋๋ก ์ฎ๊ธฐ๋ ๊ฑฐ์์ฃ :
// โ ๋์ ์: ๋ฉ์ธ ์ค๋ ๋์์ ๋ฌด๊ฑฐ์ด ์์
func applyFilter(to image: UIImage) -> UIImage {
// ๋ณต์กํ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ์์
let processedImage = heavyImageProcessing(image)
return processedImage
}
// โ
์ข์ ์: ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋ ํ์ฉ
func applyFilter(to image: UIImage, completion: @escaping (UIImage) -> Void) {
DispatchQueue.global(qos: .userInitiated).async {
let processedImage = self.heavyImageProcessing(image)
DispatchQueue.main.async {
completion(processedImage)
}
}
}
์ด๋ ๊ฒ ์์ ํ๋ ์ฑ์ด ํจ์ฌ ๋ถ๋๋ฌ์์ก์ด์! ์ฌ์ฉ์๋ค๋ "์ฑ์ด ๋นจ๋ผ์ก์ด์!"๋ผ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋จ๊ฒจ์ฃผ๋๋ผ๊ณ ์. ๐
โ ๏ธ ์ฃผ์ํด์ผ ํ CPU ์ฑ๋ฅ ํฌ๋ฌ๋ค
1. ๋ฉ์ธ ์ค๋ ๋์์์ ๋ฌด๊ฑฐ์ด ์์
UI ์
๋ฐ์ดํธ ์ธ์ ์์
์ ๊ฐ๋ฅํ ํ ๋ฐฑ๊ทธ๋ผ์ด๋๋ก ๋ณด๋ด์ธ์!
2. ๋ถํ์ํ ๋ฐ๋ณต๋ฌธ
ํนํ ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์ O(nยฒ) ๋ณต์ก๋๋ก ์ฑ๋ฅ์ ํฌ๊ฒ ์ ํ์์ผ์.
3. ๊ณผ๋ํ ๋ทฐ ๊ณ์ธต ๊ตฌ์กฐ
๋ทฐ๊ฐ ๋๋ฌด ๊น๊ฒ ์ค์ฒฉ๋๋ฉด ๋ ๋๋ง ์ฑ๋ฅ์ด ๋จ์ด์ ธ์.
4. ๋๊ธฐ์ ๋คํธ์ํฌ ํธ์ถ
์ ๋๋ก ๋ฉ์ธ ์ค๋ ๋์์ ๋๊ธฐ์ ์ผ๋ก ๋คํธ์ํฌ ์์ฒญ์ ํ๋ฉด ์ ๋ผ์!
๐พ ๋ฉ๋ชจ๋ฆฌ ์ต์ ํ: Allocations & Leaks ๋ง์คํฐํ๊ธฐ
๋ค์์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์์! ๋ฉ๋ชจ๋ฆฌ๋ iOS ๊ฐ๋ฐ์์ ์ ๋ง ์ค์ํ ์ฃผ์ ์ฃ . ๐ง
iOS๋ ๋ฐ์คํฌํฑ๊ณผ ๋ฌ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ํ์ ์ด์์. ์ฑ์ด ๋๋ฌด ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด ์์คํ
์ด ๊ฐ์ ๋ก ์ข
๋ฃ์์ผ๋ฒ๋ ค์. ์ฌ์ฉ์ ์
์ฅ์์๋ ๊ทธ๋ฅ "์ฑ์ด ๊บผ์ก๋ค"๊ณ ๋๋ผ๋ ๊ฑฐ์ฃ . ๐ข
Instruments์ Allocations์ Leaks ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๋ฅผ ํจ๊ณผ์ ์ผ๋ก ์ฐพ์๋ผ ์ ์์ด์!
๐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ๊ธฐ๋ณธ ์์น
iOS๋ ARC(Automatic Reference Counting)๋ฅผ ์ฌ์ฉํด์. ์ฝ๊ฒ ๋งํ๋ฉด, ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๊ณณ์ด ์์ผ๋ฉด ์๋์ผ๋ก ๋ฉ๋ชจ๋ฆฌ์์ ํด์ ๋๋ค๋ ๊ฑฐ์์.
ํ์ง๋ง ARC๊ฐ ์๋ฒฝํ์ง๋ ์์์. ์ํ ์ฐธ์กฐ(Retain Cycle)๊ฐ ๋ฐ์ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ์๊ธฐ์ฃ . ์ด๊ฒ ๋ฐ๋ก ์ฐ๋ฆฌ๊ฐ ์กฐ์ฌํด์ผ ํ ๋ถ๋ถ์ด์์! ๐ฏ
๐ Allocations ๋๊ตฌ ํ์ฉํ๊ธฐ
Allocations ๋๊ตฌ๋ ์ฑ์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง ์ค์๊ฐ์ผ๋ก ๋ณด์ฌ์ค์. ํนํ ๋ค์ ์ ๋ณด๋ค์ด ์ ์ฉํด์:
โข All Heap & Anonymous VM: ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
โข Persistent Bytes: ๊ณ์ ์ ์ง๋๋ ๋ฉ๋ชจ๋ฆฌ
โข Transient Bytes: ์ผ์์ ์ผ๋ก ์ฌ์ฉ๋๋ ๋ฉ๋ชจ๋ฆฌ
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ๊ณ์ ์ฆ๊ฐํ๊ธฐ๋ง ํ๊ณ ์ค์ด๋ค์ง ์๋๋ค๋ฉด? ๊ทธ๊ฑด ๋ฉ๋ชจ๋ฆฌ ๋์์ ์ ํธ์์! ๐จ
๐ ๋ฉ๋ชจ๋ฆฌ ๋์ ์ฐพ๋ ์ค์ ํ
1. Mark Generation ํ์ฉํ๊ธฐ
ํน์ ์์
์ ํ๋ก "Mark Generation"์ ์ฐ์ด๋ณด์ธ์. ์์
์ด ๋๋ฌ๋๋ฐ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํด์ ๋์ง ์์ผ๋ฉด ๋์๊ฐ ์๋ ๊ฑฐ์์.
2. ๋ฐ๋ณต ํ
์คํธํ๊ธฐ
๊ฐ์ ํ๋ฉด์ ์ฌ๋ฌ ๋ฒ ์ด๊ณ ๋ซ์๋ณด์ธ์. ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ์ ์ฆ๊ฐํ๋ค๋ฉด ๋ฌธ์ ๊ฐ ์๋ ๊ฑฐ์ฃ .
3. Snapshot ๋น๊ตํ๊ธฐ
๋ ์์ ์ ๋ฉ๋ชจ๋ฆฌ ์ํ๋ฅผ ๋น๊ตํด์ ์ด๋ค ๊ฐ์ฒด๊ฐ ํด์ ๋์ง ์์๋์ง ํ์ธํ ์ ์์ด์.
๐ Leaks ๋๊ตฌ๋ก ๋ฉ๋ชจ๋ฆฌ ๋์ ์ก๊ธฐ
Leaks ๋๊ตฌ๋ ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ์๋์ผ๋ก ๊ฐ์งํด์ค์. ๋์๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ๋นจ๊ฐ์์ผ๋ก ํ์๋๊ณ , ์ด๋์ ๋ฐ์ํ๋์ง ์ ํํ ์๋ ค์ค์. ๐ฏ
๊ฐ์ฅ ํํ ๋ฉ๋ชจ๋ฆฌ ๋์ ํจํด์ ์ดํด๋ณผ๊น์?
// โ ์ํ ์ฐธ์กฐ ๋ฐ์ ์์
class ViewController: UIViewController {
var completionHandler: (() -> Void)?
override func viewDidLoad() {
super.viewDidLoad()
// self๋ฅผ ๊ฐํ๊ฒ ์บก์ฒํ์ฌ ์ํ ์ฐธ์กฐ ๋ฐ์!
completionHandler = {
self.updateUI()
}
}
func updateUI() {
// UI ์
๋ฐ์ดํธ ์ฝ๋
}
}
// โ
weak self๋ก ์ํ ์ฐธ์กฐ ๋ฐฉ์ง
class ViewController: UIViewController {
var completionHandler: (() -> Void)?
override func viewDidLoad() {
super.viewDidLoad()
// weak self๋ก ์ํ ์ฐธ์กฐ ๋ฐฉ์ง!
completionHandler = { [weak self] in
self?.updateUI()
}
}
func updateUI() {
// UI ์
๋ฐ์ดํธ ์ฝ๋
}
}
ํด๋ก์ ์์ [weak self]๋ฅผ ์ฌ์ฉํ๋ ๊ฑด iOS ๊ฐ๋ฐ์์ ๊ธฐ๋ณธ ์ต๊ด์ด ๋์ด์ผ ํด์! ๐ช
๋ ๋ค๋ฅธ ํํ ์ค์๋ Delegate ํจํด์์ ๋ฐ์ํด์:
// โ Delegate๋ฅผ strong์ผ๋ก ์ ์ธ
protocol CustomDelegate: AnyObject {
func didFinish()
}
class CustomView: UIView {
var delegate: CustomDelegate? // ์ํ ์ฐธ์กฐ ์ํ!
}
// โ
Delegate๋ ํญ์ weak์ผ๋ก!
class CustomView: UIView {
weak var delegate: CustomDelegate? // ์์ !
}
๐ก ๋ฉ๋ชจ๋ฆฌ ์ต์ ํ ์ฒดํฌ๋ฆฌ์คํธ
โ ํด๋ก์ ์์ self ์ฌ์ฉ ์ [weak self] ๋๋ [unowned self] ์ฌ์ฉ
โ Delegate๋ ํญ์ weak์ผ๋ก ์ ์ธ
โ ํฐ ์ด๋ฏธ์ง๋ ์ฌ์ฉ ํ ์ฆ์ ํด์
โ ์บ์๋ ์ ์ ํ ํฌ๊ธฐ ์ ํ ์ค์
โ ๋ฐฑ๊ทธ๋ผ์ด๋๋ก ์ด๋ ์ ๋ถํ์ํ ๋ฆฌ์์ค ํด์
โ ๋ฉ๋ชจ๋ฆฌ ์๋ ๋ฐ์ ์ ์ ์ ํ ๋์ ๊ตฌํ
์ค์ ๋ก ์ ๊ฐ ์์
ํ๋ ์์
๋ฏธ๋์ด ์ฑ์์๋ ์ด๋ฏธ์ง ์บ์ฑ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๊ฐ ์์์ด์. ์ฌ์ฉ์๊ฐ ํผ๋๋ฅผ ์คํฌ๋กคํ๋ฉด์ ์๋ฐฑ ์ฅ์ ์ด๋ฏธ์ง๋ฅผ ๋ก๋ํ๋๋ฐ, ๋ชจ๋ ์ด๋ฏธ์ง๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์งํ๋๊น ์ฑ์ด ํฌ๋์๋๋๋ผ๊ณ ์. ๐ฐ
ํด๊ฒฐ์ฑ
์ NSCache๋ฅผ ์ฌ์ฉํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ์๋์ด ๋ฐ์ํ๋ฉด ์บ์๋ฅผ ๋น์ฐ๋ ๊ฑฐ์์ด์:
class ImageCache {
static let shared = ImageCache()
private let cache = NSCache<NSString, UIImage>()
init() {
// ๋ฉ๋ชจ๋ฆฌ ์๋ ๊ฐ์ง
NotificationCenter.default.addObserver(
self,
selector: #selector(clearCache),
name: UIApplication.didReceiveMemoryWarningNotification,
object: nil
)
// ์บ์ ํฌ๊ธฐ ์ ํ ์ค์
cache.countLimit = 100 // ์ต๋ 100๊ฐ ์ด๋ฏธ์ง
cache.totalCostLimit = 50 * 1024 * 1024 // ์ต๋ 50MB
}
@objc func clearCache() {
cache.removeAllObjects()
}
func setImage(_ image: UIImage, forKey key: String) {
cache.setObject(image, forKey: key as NSString)
}
func getImage(forKey key: String) -> UIImage? {
return cache.object(forKey: key as NSString)
}
}
์ด๋ ๊ฒ ์์ ํ๋ ๋ฉ๋ชจ๋ฆฌ ํฌ๋์๊ฐ ์์ ํ ์ฌ๋ผ์ก์ด์! ๐
๐ ๋ฐฐํฐ๋ฆฌ ์ต์ ํ: Energy Log๋ก ์ ๋ ฅ ์๋น ์ค์ด๊ธฐ
๋ฐฐํฐ๋ฆฌ ์ต์ ํ๋ ์ฌ์ฉ์ ๋ง์กฑ๋์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์ณ์. ์๋ฌด๋ฆฌ ์ข์ ์ฑ์ด๋ผ๋ ๋ฐฐํฐ๋ฆฌ๋ฅผ ๋นจ๋ฆฌ ์๋ชจ์ํค๋ฉด ์ฌ์ฉ์๋ค์ด ์ญ์ ํด๋ฒ๋ฆฌ๊ฑฐ๋ ์. ๐๐ข
Instruments์ Energy Log ๋๊ตฌ๋ ์ฑ์ด ์ด๋ค ์์
์์ ์ผ๋ง๋ ๋ง์ ์ ๋ ฅ์ ์๋นํ๋์ง ๋ณด์ฌ์ค์. ํนํ ๋ค์ ํญ๋ชฉ๋ค์ ์ฃผ์ ๊น๊ฒ ๋ด์ผ ํด์:
โก ์ฃผ์ ์ ๋ ฅ ์๋น ์์ธ๋ค
1. CPU ์ฌ์ฉ๋ ๐ฅ๏ธ
CPU๋ฅผ ๋ง์ด ์ฌ์ฉํ ์๋ก ๋ฐฐํฐ๋ฆฌ๊ฐ ๋นจ๋ฆฌ ๋ณ์์. ๋ถํ์ํ ์ฐ์ฐ์ ์ค์ด๋ ๊ฒ ์ค์ํด์.
2. ๋คํธ์ํฌ ํ๋ ๐ก
์
๋ฃฐ๋ฌ ๋ฐ์ดํฐ ์ฌ์ฉ์ ํนํ ์ ๋ ฅ์ ๋ง์ด ์๋ชจํด์. ์์ฒญ์ ๋ฐฐ์น๋ก ๋ฌถ์ด์ ๋ณด๋ด๋ ๊ฒ ์ข์์.
3. ์์น ์๋น์ค ๐
GPS๋ ๋ฐฐํฐ๋ฆฌ ํฌ๋ฌ์์! ์ ํ๋ ์ค์ ์ ์ ์ ํ ์กฐ์ ํด์ผ ํด์.
4. ํ๋ฉด ์
๋ฐ์ดํธ ๐จ
๋ถํ์ํ ํ๋ฉด ๊ฐฑ์ ์ ์ ๋ ฅ ๋ญ๋น์์. ๋ณ๊ฒฝ๋ ๋ถ๋ถ๋ง ์
๋ฐ์ดํธํ์ธ์.
5. ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
๐
๋ฐฑ๊ทธ๋ผ์ด๋์์ ์คํ๋๋ ์์
์ ์ต์ํํด์ผ ํด์.
Energy Log๋ฅผ ์คํํ๋ฉด ์ฑ์ ์ ๋ ฅ ์๋น ํจํด์ ์๊ฐ๋๋ณ๋ก ๋ณผ ์ ์์ด์. ๊ทธ๋ํ์์ ๊ธ๊ฒฉํ ์น์๋ ๋ถ๋ถ์ด ์๋ค๋ฉด, ๊ทธ ์์ ์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋ฌ๋์ง ํ์ธํด๋ด์ผ ํด์! ๐
๐ฏ ๋ฐฐํฐ๋ฆฌ ์ต์ ํ ์ค์ ์ ๋ต
์์น ์๋น์ค ์ต์ ํ
ํญ์ ์ต๊ณ ์ ํ๋๊ฐ ํ์ํ ๊ฑด ์๋์์. ์ํฉ์ ๋ง๋ ์ ํ๋๋ฅผ ์ ํํ์ธ์:
import CoreLocation
class LocationManager: NSObject, CLLocationManagerDelegate {
let locationManager = CLLocationManager()
func setupLocationManager() {
locationManager.delegate = self
// โ ๋์ ์: ํญ์ ์ต๊ณ ์ ํ๋
// locationManager.desiredAccuracy = kCLLocationAccuracyBest
// โ
์ข์ ์: ํ์์ ๋ง๋ ์ ํ๋ ์ ํ
// ๋๋ต์ ์ธ ์์น๋ง ํ์ํ ๊ฒฝ์ฐ
locationManager.desiredAccuracy = kCLLocationAccuracyKilometer
// ๋ฐฐํฐ๋ฆฌ ์ ์ฝ ๋ชจ๋
locationManager.pausesLocationUpdatesAutomatically = true
locationManager.allowsBackgroundLocationUpdates = false
// ๊ฑฐ๋ฆฌ ํํฐ ์ค์ (100m ์ด๋ ์์๋ง ์
๋ฐ์ดํธ)
locationManager.distanceFilter = 100
}
// ํ์ํ ๋๋ง ์์น ์
๋ฐ์ดํธ ์์
func startTracking() {
locationManager.startUpdatingLocation()
}
// ์ฌ์ฉ ํ ์ฆ์ ์ค์ง!
func stopTracking() {
locationManager.stopUpdatingLocation()
}
}
๋คํธ์ํฌ ์์ฒญ ์ต์ ํ
๋คํธ์ํฌ ์์ฒญ์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๋ ๊ฒ๋ ์ค์ํด์. ์ฌ๋ฌ ๊ฐ์ ์์ ์์ฒญ๋ณด๋ค๋ ํ๋์ ํฐ ์์ฒญ์ผ๋ก ๋ฌถ๋ ๊ฒ ๋ฐฐํฐ๋ฆฌ์ ์ข์์:
// โ ๋์ ์: ์ฌ๋ฌ ๋ฒ์ ๊ฐ๋ณ ์์ฒญ
func loadUserData() {
fetchUserProfile()
fetchUserPosts()
fetchUserFriends()
fetchUserNotifications()
}
// โ
์ข์ ์: ๋ฐฐ์น ์์ฒญ์ผ๋ก ๋ฌถ๊ธฐ
func loadUserData() {
let group = DispatchGroup()
// ๋ชจ๋ ์์ฒญ์ ๋์์ ์์
group.enter()
fetchUserProfile { group.leave() }
group.enter()
fetchUserPosts { group.leave() }
group.enter()
fetchUserFriends { group.leave() }
group.enter()
fetchUserNotifications { group.leave() }
group.notify(queue: .main) {
// ๋ชจ๋ ๋ฐ์ดํฐ ๋ก๋ ์๋ฃ
self.updateUI()
}
}
// ๐ ๋ ์ข์ ์: ์๋ฒ์์ ํ ๋ฒ์ ๋ฐ๊ธฐ
func loadUserData() {
// ์๋ฒ API๋ฅผ ์์ ํด์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ๋ฐ๊ธฐ
APIClient.fetchUserDataBundle { result in
switch result {
case .success(let bundle):
self.updateWithBundle(bundle)
case .failure(let error):
self.handleError(error)
}
}
}
โ ๏ธ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ฃผ์์ฌํญ
iOS๋ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ ์๊ฒฉํ๊ฒ ์ ํํด์. ๋ถํ์ํ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ ์ฑ์ด ์ข
๋ฃ๋ ์ ์์ด์!
๋ฐฑ๊ทธ๋ผ์ด๋์์ ํ์ฉ๋๋ ์์
:
โข ์ค๋์ค ์ฌ์
โข ์์น ์
๋ฐ์ดํธ
โข VoIP
โข ๋ด์ค์คํ ๋ ๋ค์ด๋ก๋
โข ์ธ๋ถ ์ก์ธ์๋ฆฌ ํต์
โข ๋ธ๋ฃจํฌ์ค ํต์
โข ๋ฐฑ๊ทธ๋ผ์ด๋ ํ์น
โข ์๊ฒฉ ์๋ฆผ
์ด์ธ์ ์์
์ ๊ฐ๋ฅํ ํ ํฌ๊ทธ๋ผ์ด๋์์ ์ฒ๋ฆฌํ์ธ์!
์ ๊ฐ ์ด๋ ์ถ์ ์ฑ์ ๋ง๋ค ๋ ๋ฐฐ์ด ๊ตํ์ด ์์ด์. ์ฒ์์๋ 1์ด๋ง๋ค ์์น๋ฅผ ์
๋ฐ์ดํธํ๋๋ฐ, ๋ฐฐํฐ๋ฆฌ๊ฐ 2์๊ฐ ๋ง์ ๋ค ๋ณ๋๋ผ๊ณ ์. ๐ฑ
๊ทธ๋์ ๋ค์๊ณผ ๊ฐ์ด ์ต์ ํํ์ด์:
class WorkoutTracker {
let locationManager = CLLocationManager()
var isWorkoutActive = false
func startWorkout() {
isWorkoutActive = true
// ์ด๋ ์ค์๋ ๋์ ์ ํ๋ ํ์
locationManager.desiredAccuracy = kCLLocationAccuracyBest
locationManager.distanceFilter = 10 // 10m๋ง๋ค ์
๋ฐ์ดํธ
// ํ์ง๋ง ๋ฐฐํฐ๋ฆฌ ์ ์ฝ ๊ธฐ๋ฅ์ ์ผ๋๊ธฐ
locationManager.pausesLocationUpdatesAutomatically = true
locationManager.startUpdatingLocation()
}
func pauseWorkout() {
// ์ผ์์ ์ง ์ ์์น ์
๋ฐ์ดํธ ์ค์ง
locationManager.stopUpdatingLocation()
}
func stopWorkout() {
isWorkoutActive = false
locationManager.stopUpdatingLocation()
// ์ด๋ ์ข
๋ฃ ํ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ ๋ฆฌ
cleanupBackgroundTasks()
}
}
์ด๋ ๊ฒ ์์ ํ๋ ๋ฐฐํฐ๋ฆฌ ์ฌ์ฉ ์๊ฐ์ด 6์๊ฐ ์ด์์ผ๋ก ๋์ด๋ฌ์ด์! ์ฌ์ฉ์๋ค๋ ์ ๋ง ์ข์ํ์ฃ . ๐
๐จ UI ์ฑ๋ฅ ์ต์ ํ: Core Animation๊ณผ ๋ ๋๋ง
๋ถ๋๋ฌ์ด UI๋ ์ข์ ์ฑ์ ํ์ ์กฐ๊ฑด์ด์์! ์ฌ์ฉ์๋ค์ 60fps(์ด๋น 60ํ๋ ์)์ ๋ถ๋๋ฌ์ด ์ ๋๋ฉ์ด์
์ ๊ธฐ๋ํ๊ฑฐ๋ ์. ๐ฌ
ํ์ง๋ง ๋ณต์กํ UI๋ ๋นํจ์จ์ ์ธ ๋ ๋๋ง ๋๋ฌธ์ ํ๋ ์์ด ๋จ์ด์ง๋ฉด ์ฑ์ด ๋ฒ๋ฒ
๊ฑฐ๋ฆฌ๋ ๋๋์ ๋ฐ๊ฒ ๋ผ์. ์ด๋ฅผ ํ๋ ์ ๋๋กญ(Frame Drop)์ด๋ผ๊ณ ํด์.
๐ ๋ ๋๋ง ํ์ดํ๋ผ์ธ ์ดํดํ๊ธฐ
iOS์ ํ๋ฉด ๋ ๋๋ง์ ๋ค์ ๋จ๊ณ๋ฅผ ๊ฑฐ์ณ์:
1. Layout - ๋ทฐ์ ์์น์ ํฌ๊ธฐ ๊ณ์ฐ
2. Display - ๋ทฐ์ ๋ด์ฉ ๊ทธ๋ฆฌ๊ธฐ
3. Prepare - ์ด๋ฏธ์ง ๋์ฝ๋ฉ ๋ฑ ์ค๋น ์์
4. Commit - ๋ ์ด์ด ํธ๋ฆฌ๋ฅผ ๋ ๋ ์๋ฒ๋ก ์ ์ก
์ด ๋ชจ๋ ๊ณผ์ ์ด 16.67ms(1/60์ด) ์์ ์๋ฃ๋์ด์ผ 60fps๋ฅผ ์ ์งํ ์ ์์ด์! โฑ๏ธ
๐ Core Animation Instrument ํ์ฉํ๊ธฐ
Core Animation ๋๊ตฌ๋ ๋ค์๊ณผ ๊ฐ์ ์ ์ฉํ ๋๋ฒ๊ทธ ์ต์ ์ ์ ๊ณตํด์:
๐จ Core Animation ๋๋ฒ๊ทธ ์ต์
๋ค
Color Blended Layers (๋ธ๋ ๋ฉ ๋ ์ด์ด ํ์)
๋นจ๊ฐ์์ผ๋ก ํ์๋๋ ๋ถ๋ถ์ ์ฌ๋ฌ ๋ ์ด์ด๊ฐ ๊ฒน์ณ์ ๋ธ๋ ๋ฉ๋๋ ๊ณณ์ด์์. ์ฑ๋ฅ์ ์ ์ข์์!
Color Hits Green and Misses Red (๋์คํฐํ ํจ๊ณผ)
shouldRasterize๊ฐ ํจ๊ณผ์ ์ผ๋ก ์๋ํ๋์ง ๋ณด์ฌ์ค์. ๋
น์์ด ์ข๊ณ ๋นจ๊ฐ์์ ๋๋น ์.
Color Copied Images (๋ณต์ฌ๋ ์ด๋ฏธ์ง)
์ด๋ฏธ์ง๊ฐ CPU์์ ๋ณต์ฌ๋๋ ๊ฒฝ์ฐ๋ฅผ ํ๋์์ผ๋ก ํ์ํด์. ํผํด์ผ ํ ์ํฉ์ด์์.
Color Misaligned Images (์ ๋ ฌ๋์ง ์์ ์ด๋ฏธ์ง)
์ด๋ฏธ์ง ํฌ๊ธฐ๊ฐ ๋ทฐ ํฌ๊ธฐ์ ๋ง์ง ์์ผ๋ฉด ๋
ธ๋์์ผ๋ก ํ์๋ผ์. ๋ฆฌ์ฌ์ด์ง ๋น์ฉ์ด ๋ฐ์ํด์.
Color Offscreen-Rendered (์คํ์คํฌ๋ฆฐ ๋ ๋๋ง)
๋
ธ๋์์ผ๋ก ํ์๋๋ ๋ถ๋ถ์ ์คํ์คํฌ๋ฆฐ ๋ ๋๋ง์ด ๋ฐ์ํ๋ ๊ณณ์ด์์. ์ฑ๋ฅ ์ ํ์ ์ฃผ๋ฒ!
์ค์ ๋ก ๊ฐ์ฅ ๋ง์ด ๋ฐ์ํ๋ UI ์ฑ๋ฅ ๋ฌธ์ ๋ค์ ์ดํด๋ณผ๊น์?
// โ ๋ฌธ์ 1: ๋ถํฌ๋ช
๋ ์ค์ ์ ํจ
class CustomView: UIView {
override init(frame: CGRect) {
super.init(frame: frame)
backgroundColor = .white
// isOpaque๋ฅผ ์ค์ ํ์ง ์์ผ๋ฉด ๋ธ๋ ๋ฉ ๋ฐ์!
}
}
// โ
ํด๊ฒฐ: ๋ถํฌ๋ช
๋ทฐ๋ ๋ช
์์ ์ผ๋ก ํ์
class CustomView: UIView {
override init(frame: CGRect) {
super.init(frame: frame)
backgroundColor = .white
isOpaque = true // ๋ธ๋ ๋ฉ ๋ฐฉ์ง!
}
}
// โ ๋ฌธ์ 2: ๊ทธ๋ฆผ์์ ๋ชจ์๋ฆฌ ๋ฅ๊ธ๊ฒ ๋์ ์ฌ์ฉ
class CardView: UIView {
override init(frame: CGRect) {
super.init(frame: frame)
layer.cornerRadius = 10
layer.shadowOpacity = 0.5
layer.shadowRadius = 5
// ์คํ์คํฌ๋ฆฐ ๋ ๋๋ง ๋ฐ์! ์ฑ๋ฅ ์ ํ!
}
}
// โ
ํด๊ฒฐ: shadowPath ์ฌ์ฉ
class CardView: UIView {
override init(frame: CGRect) {
super.init(frame: frame)
layer.cornerRadius = 10
layer.shadowOpacity = 0.5
layer.shadowRadius = 5
// shadowPath๋ฅผ ๋ช
์ํ๋ฉด ์คํ์คํฌ๋ฆฐ ๋ ๋๋ง ๋ฐฉ์ง!
layer.shadowPath = UIBezierPath(
roundedRect: bounds,
cornerRadius: layer.cornerRadius
).cgPath
}
override func layoutSubviews() {
super.layoutSubviews()
// ํฌ๊ธฐ๊ฐ ๋ณ๊ฒฝ๋๋ฉด shadowPath๋ ์
๋ฐ์ดํธ
layer.shadowPath = UIBezierPath(
roundedRect: bounds,
cornerRadius: layer.cornerRadius
).cgPath
}
}
ํ
์ด๋ธ๋ทฐ์ ์ปฌ๋ ์
๋ทฐ ์ต์ ํ
์คํฌ๋กค ์ฑ๋ฅ์ ์ฑ์ ์ฒซ์ธ์์ ๊ฒฐ์ ํด์. ๋ถ๋๋ฌ์ด ์คํฌ๋กค์ ์ํ ํต์ฌ ํ๋ค์ด์์:
class OptimizedTableViewCell: UITableViewCell {
// โ
1. ์
์ฌ์ฌ์ฉ ์๋ณ์ ์ฌ์ฉ
static let identifier = "OptimizedCell"
// โ
2. ์ด๋ฏธ์ง๋ ๋ฐฑ๊ทธ๋ผ์ด๋์์ ๋ก๋
func configure(with item: Item) {
textLabel?.text = item.title
// ์ด๋ฏธ์ง ๋น๋๊ธฐ ๋ก๋
DispatchQueue.global(qos: .userInitiated).async {
guard let image = self.loadImage(from: item.imageURL) else { return }
DispatchQueue.main.async {
self.imageView?.image = image
}
}
}
// โ
3. ๋ณต์กํ ๋ ์ด์์์ ์บ์ฑ
override func layoutSubviews() {
super.layoutSubviews()
// ๋ ์ด์์ ๊ณ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑํ์ฌ ์ฌ์ฌ์ฉ
if cachedLayout == nil {
cachedLayout = calculateLayout()
}
applyLayout(cachedLayout!)
}
// โ
4. ๋ถํฌ๋ช
๋ฐฐ๊ฒฝ ์ฌ์ฉ
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
backgroundColor = .white
contentView.isOpaque = true
}
}
// TableView ์ค์
class OptimizedViewController: UIViewController {
let tableView = UITableView()
func setupTableView() {
// โ
5. ์
๋์ด ์ถ์ ์น ์ ๊ณต
tableView.estimatedRowHeight = 80
tableView.rowHeight = UITableView.automaticDimension
// โ
6. ํ๋ฆฌํ์นญ ํ์ฑํ (iOS 10+)
tableView.prefetchDataSource = self
// โ
7. ์
๋ฑ๋ก
tableView.register(
OptimizedTableViewCell.self,
forCellReuseIdentifier: OptimizedTableViewCell.identifier
)
}
}
extension OptimizedViewController: UITableViewDataSourcePrefetching {
func tableView(_ tableView: UITableView, prefetchRowsAt indexPaths: [IndexPath]) {
// ๋ฏธ๋ฆฌ ๋ฐ์ดํฐ ๋ก๋
for indexPath in indexPaths {
preloadData(at: indexPath)
}
}
}
๐ก ์ด๋ฏธ์ง ์ต์ ํ ๊ฟํ
1. ์ ์ ํ ํฌ๊ธฐ๋ก ๋ฆฌ์ฌ์ด์ง
ํฐ ์ด๋ฏธ์ง๋ฅผ ์์ ์ด๋ฏธ์ง๋ทฐ์ ํ์ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น์์. ๋ฏธ๋ฆฌ ๋ฆฌ์ฌ์ด์งํ์ธ์!
2. ์ด๋ฏธ์ง ํฌ๋งท ์ ํ
โข PNG: ํฌ๋ช
๋๊ฐ ํ์ํ ๊ฒฝ์ฐ
โข JPEG: ์ฌ์ง ๊ฐ์ ๋ณต์กํ ์ด๋ฏธ์ง
โข HEIF: iOS 11+ ์์ ๋ ํจ์จ์
3. ์ด๋ฏธ์ง ์บ์ฑ
๊ฐ์ ์ด๋ฏธ์ง๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ก๋ํ์ง ๋ง์ธ์. NSCache๋ ์๋ํํฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ(SDWebImage, Kingfisher)๋ฅผ ์ฌ์ฉํ์ธ์!
4. ๋ ์ด์ง ๋ก๋ฉ
ํ๋ฉด์ ๋ณด์ด๋ ์ด๋ฏธ์ง๋ง ๋ก๋ํ์ธ์. ์คํฌ๋กคํ๋ฉด์ ํ์ํ ๋ ๋ก๋ํ๋ ๊ฒ ํจ์จ์ ์ด์์.
์ค์ ์ฌ๋ก๋ฅผ ํ๋ ๋ ๊ณต์ ํ ๊ฒ์. ์ ๊ฐ ์์
ํ ๋ด์ค ์ฑ์์ ํผ๋ ์คํฌ๋กค์ด ์ ๋ง ๋ฒ๋ฒ
๊ฑฐ๋ ธ์ด์. Core Animation์ผ๋ก ๋ถ์ํด๋ณด๋ ๋ค์ ๋ฌธ์ ๋ค์ด ์์์ด์:
๋ฌธ์ ์ :
โข ์
๋ง๋ค ๊ทธ๋ฆผ์ ํจ๊ณผ ์ฌ์ฉ (์คํ์คํฌ๋ฆฐ ๋ ๋๋ง)
โข ์๋ณธ ํฌ๊ธฐ ์ด๋ฏธ์ง๋ฅผ ์์ ์ธ๋ค์ผ๋ก ํ์
โข ์
๋์ด๋ฅผ ๋งค๋ฒ ๊ณ์ฐ
ํด๊ฒฐ์ฑ
:
โข ๊ทธ๋ฆผ์ ๋์ ํ
๋๋ฆฌ ์ฌ์ฉ
โข ์๋ฒ์์ ์ธ๋ค์ผ ํฌ๊ธฐ๋ก ์ด๋ฏธ์ง ๋ฐ๊ธฐ
โข ์
๋์ด ์บ์ฑ
๊ฒฐ๊ณผ? ์คํฌ๋กค์ด ๋ฒํฐ์ฒ๋ผ ๋ถ๋๋ฌ์์ก์ด์! ๐งโจ
๐ ๋คํธ์ํฌ ์ฑ๋ฅ ์ต์ ํ
๋คํธ์ํฌ๋ ํ๋ ์ฑ์ ์๋ช
์ค์ด์์. ํ์ง๋ง ์๋ชป ์ฌ์ฉํ๋ฉด ์ฑ์ ๋๋ฆฌ๊ฒ ๋ง๋ค๊ณ ๋ฐฐํฐ๋ฆฌ๋ฅผ ๋นจ๋ฆฌ ์๋ชจ์ํค์ฃ . ๐ฑ๐จ
Instruments์ Network ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ๋คํธ์ํฌ ํ๋์ ๋ชจ๋ํฐ๋งํ ์ ์์ด์. ์ด๋ค ์์ฒญ์ด ์ผ๋ง๋ ์ค๋ ๊ฑธ๋ฆฌ๋์ง, ์ผ๋ง๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋์ง ํ๋์ ๋ณผ ์ ์์ฃ !
๐ ๋คํธ์ํฌ ์ต์ ํ ํต์ฌ ์ ๋ต
1. ์์ฒญ ํ์ ์ค์ด๊ธฐ
์ฌ๋ฌ ๊ฐ์ ์์ ์์ฒญ๋ณด๋ค ํ๋์ ํฐ ์์ฒญ์ด ํจ์จ์ ์ด์์.
2. ์๋ต ํฌ๊ธฐ ์ค์ด๊ธฐ
ํ์ํ ๋ฐ์ดํฐ๋ง ์์ฒญํ๊ณ , ์์ถ์ ํ์ฉํ์ธ์.
3. ์บ์ฑ ํ์ฉํ๊ธฐ
๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ณตํด์ ์์ฒญํ์ง ๋ง์ธ์.
4. ์ฐ๊ฒฐ ์ฌ์ฌ์ฉํ๊ธฐ
HTTP/2๋ฅผ ์ฌ์ฉํ๋ฉด ์ฐ๊ฒฐ์ ์ฌ์ฌ์ฉํ ์ ์์ด์.
5. ํ์์์ ์ค์ ํ๊ธฐ
๋ฌดํ์ ๊ธฐ๋ค๋ฆฌ์ง ๋ง๊ณ ์ ์ ํ ํ์์์์ ์ค์ ํ์ธ์.
์ค์ ์ฝ๋๋ฅผ ์ดํด๋ณผ๊น์?
import Foundation
class NetworkManager {
static let shared = NetworkManager()
// โ
URLSession ์ค์ ์ต์ ํ
private lazy var session: URLSession = {
let config = URLSessionConfiguration.default
// ํ์์์ ์ค์
config.timeoutIntervalForRequest = 30
config.timeoutIntervalForResource = 300
// HTTP ์ต๋ ์ฐ๊ฒฐ ์ ์ค์
config.httpMaximumConnectionsPerHost = 5
// ์บ์ ์ ์ฑ
์ค์
config.requestCachePolicy = .returnCacheDataElseLoad
config.urlCache = URLCache(
memoryCapacity: 50 * 1024 * 1024, // 50MB ๋ฉ๋ชจ๋ฆฌ ์บ์
diskCapacity: 100 * 1024 * 1024, // 100MB ๋์คํฌ ์บ์
diskPath: "network_cache"
)
return URLSession(configuration: config)
}()
// โ
์์ฒญ ๋ฐฐ์น ์ฒ๋ฆฌ
func fetchMultipleResources(ids: [String], completion: @escaping ([Resource]) -> Void) {
// ์ฌ๋ฌ ๊ฐ์ ๊ฐ๋ณ ์์ฒญ ๋์ ํ ๋ฒ์ ์์ฒญ
let idsString = ids.joined(separator: ",")
let url = URL(string: "https://api.example.com/resources?ids=\(idsString)")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
// ์์ถ ์์ฒญ
request.setValue("gzip, deflate", forHTTPHeaderField: "Accept-Encoding")
session.dataTask(with: request) { data, response, error in
guard let data = data else { return }
// JSON ํ์ฑ
if let resources = try? JSONDecoder().decode([Resource].self, from: data) {
completion(resources)
}
}.resume()
}
// โ
์ด๋ฏธ์ง ๋ค์ด๋ก๋ ์ต์ ํ
private var imageCache = NSCache<NSString, UIImage>()
func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
let cacheKey = url.absoluteString as NSString
// ์บ์ ํ์ธ
if let cachedImage = imageCache.object(forKey: cacheKey) {
completion(cachedImage)
return
}
// ๋คํธ์ํฌ์์ ๋ค์ด๋ก๋
session.dataTask(with: url) { [weak self] data, response, error in
guard let data = data,
let image = UIImage(data: data) else {
completion(nil)
return
}
// ์บ์์ ์ ์ฅ
self?.imageCache.setObject(image, forKey: cacheKey)
completion(image)
}.resume()
}
// โ
์ฌ์๋ ๋ก์ง ๊ตฌํ
func fetchWithRetry<T: Decodable>(
url: URL,
maxRetries: Int = 3,
completion: @escaping (Result<T, Error>) -> Void
) {
fetchData(url: url, retriesLeft: maxRetries, completion: completion)
}
private func fetchData<T: Decodable>(
url: URL,
retriesLeft: Int,
completion: @escaping (Result<T, Error>) -> Void
) {
session.dataTask(with: url) { data, response, error in
if let error = error {
if retriesLeft > 0 {
// ์ง์ ๋ฐฑ์คํ๋ก ์ฌ์๋
let delay = pow(2.0, Double(3 - retriesLeft))
DispatchQueue.global().asyncAfter(deadline: .now() + delay) {
self.fetchData(url: url, retriesLeft: retriesLeft - 1, completion: completion)
}
} else {
completion(.failure(error))
}
return
}
guard let data = data else {
completion(.failure(NetworkError.noData))
return
}
do {
let decoded = try JSONDecoder().decode(T.self, from: data)
completion(.success(decoded))
} catch {
completion(.failure(error))
}
}.resume()
}
}
enum NetworkError: Error {
case noData
case decodingError
}
๐ฏ API ์ค๊ณ ์ต์ ํ ํ
์๋ฒ API๋ฅผ ์ค๊ณํ ๋๋ ํด๋ผ์ด์ธํธ ์ฑ๋ฅ์ ๊ณ ๋ คํด์ผ ํด์:
1. GraphQL ๊ณ ๋ คํ๊ธฐ
ํ์ํ ๋ฐ์ดํฐ๋ง ์ ํํ ์์ฒญํ ์ ์์ด์. Over-fetching์ ๋ฐฉ์งํ ์ ์์ฃ !
2. ํ์ด์ง๋ค์ด์
๊ตฌํํ๊ธฐ
๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ๋ฐ์ง ๋ง๊ณ , ํ์ํ ๋งํผ๋ง ๋ฐ์ผ์ธ์.
3. ๋ธํ ์
๋ฐ์ดํธ ์ฌ์ฉํ๊ธฐ
๋ณ๊ฒฝ๋ ๋ฐ์ดํฐ๋ง ์ ์กํ๋ฉด ๋์ญํญ์ ํฌ๊ฒ ์ ์ฝํ ์ ์์ด์.
4. ETags ํ์ฉํ๊ธฐ
์๋ฒ์์ ETag๋ฅผ ์ ๊ณตํ๋ฉด ํด๋ผ์ด์ธํธ๊ฐ ์บ์๋ฅผ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์์ด์.
// โ
ํ์ด์ง๋ค์ด์
๊ตฌํ ์์
class FeedViewController: UIViewController {
var currentPage = 0
var isLoading = false
var hasMoreData = true
func loadMorePosts() {
guard !isLoading && hasMoreData else { return }
isLoading = true
let url = URL(string: "https://api.example.com/posts?page=\(currentPage)&limit=20")!
NetworkManager.shared.fetchWithRetry(url: url) { [weak self] (result: Result<PostsResponse, Error>) in
guard let self = self else { return }
self.isLoading = false
switch result {
case .success(let response):
self.posts.append(contentsOf: response.posts)
self.currentPage += 1
self.hasMoreData = response.hasMore
self.tableView.reloadData()
case .failure(let error):
self.showError(error)
}
}
}
}
struct PostsResponse: Decodable {
let posts: [Post]
let hasMore: Bool
let totalCount: Int
}
โ ๏ธ ๋คํธ์ํฌ ์ฌ์ฉ ์ ์ฃผ์์ฌํญ
1. ๋ฉ์ธ ์ค๋ ๋ ๋ธ๋กํน ๊ธ์ง
์ ๋๋ก ๋ฉ์ธ ์ค๋ ๋์์ ๋๊ธฐ์ ๋คํธ์ํฌ ์์ฒญ์ ํ๋ฉด ์ ๋ผ์!
2. ๋ฌดํ ์ฌ์๋ ๋ฐฉ์ง
์ฌ์๋ ํ์๋ฅผ ์ ํํ๊ณ , ์ง์ ๋ฐฑ์คํ๋ฅผ ์ฌ์ฉํ์ธ์.
3. ์ฌ์ฉ์ ๊ฒฝํ ๊ณ ๋ ค
๋ก๋ฉ ์ธ๋์ผ์ดํฐ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ , ์คํ๋ผ์ธ ์ํ๋ฅผ ์ ์ ํ ์ฒ๋ฆฌํ์ธ์.
4. ๋ณด์ ๊ณ ๋ ค
HTTPS๋ฅผ ์ฌ์ฉํ๊ณ , ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ ์ํธํํ์ธ์.
์ ๊ฐ ๊ฒฝํํ ์ฌ๋ฏธ์๋ ์ฌ๋ก๊ฐ ์์ด์. ์์
๋ฏธ๋์ด ์ฑ์์ ์ฌ์ฉ์๊ฐ ํผ๋๋ฅผ ์คํฌ๋กคํ ๋๋ง๋ค ๊ฐ ํฌ์คํธ์ ์ข์์ ์, ๋๊ธ ์๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ์์ฒญํ์์ด์. ๐
100๊ฐ ํฌ์คํธ๋ฅผ ๋ณด๋ฉด 200๊ฐ์ ๋คํธ์ํฌ ์์ฒญ์ด ๋ฐ์ํ๋ ๊ฑฐ์ฃ ! Network Instrument๋ก ํ์ธํด๋ณด๋ ๋คํธ์ํฌ ์์ฒญ์ด ํญ๋ฐ์ ์ผ๋ก ๋ง์์ด์.
ํด๊ฒฐ์ฑ
์ ๊ฐ๋จํ์ด์. ํผ๋ API์์ ํฌ์คํธ ์ ๋ณด์ ํจ๊ป ์ข์์ ์, ๋๊ธ ์๋ฅผ ํ ๋ฒ์ ๋ณด๋ด๋๋ก ์์ ํ์ฃ . ๋คํธ์ํฌ ์์ฒญ์ด 98% ๊ฐ์ํ์ด์! ๐
๐ ๏ธ ์ค์ ํ๋กํ์ผ๋ง ์ํฌํ๋ก์ฐ
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ค์ ์์ ์ด๋ป๊ฒ ํ์ฉํ๋์ง ์์๋ณผ๊น์? ์ฒด๊ณ์ ์ธ ํ๋กํ์ผ๋ง ์ํฌํ๋ก์ฐ๋ฅผ ์๊ฐํ ๊ฒ์! ๐
๐ฏ ๋จ๊ณ๋ณ ํ๋กํ์ผ๋ง ๊ฐ์ด๋
Step 1: ๋ฌธ์ ์๋ณํ๊ธฐ ๐
๋จผ์ ์ด๋ค ์ฑ๋ฅ ๋ฌธ์ ๊ฐ ์๋์ง ํ์
ํด์ผ ํด์. ์ฌ์ฉ์ ๋ฆฌ๋ทฐ, ํฌ๋์ ๋ฆฌํฌํธ, ์ง์ ํ
์คํธ๋ฅผ ํตํด ๋ฌธ์ ๋ฅผ ์ฐพ์๋ณด์ธ์.
Step 2: ๊ฐ์ค ์ธ์ฐ๊ธฐ ๐ญ
"์๋ง๋ ์ด๋ฏธ์ง ๋ก๋ฉ ๋๋ฌธ์ผ ๊ฑฐ์ผ", "๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ์๋ ๊ฒ ๊ฐ์" ๊ฐ์ ๊ฐ์ค์ ์ธ์๋ณด์ธ์.
Step 3: ์ ์ ํ ๋๊ตฌ ์ ํํ๊ธฐ ๐ ๏ธ
โข CPU ๋ฌธ์ โ Time Profiler
โข ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ โ Allocations, Leaks
โข UI ๋ฒ๋ฒ
์ โ Core Animation
โข ๋ฐฐํฐ๋ฆฌ ์๋ชจ โ Energy Log
โข ๋คํธ์ํฌ ์ง์ฐ โ Network
Step 4: ๋ฐ์ดํฐ ์์งํ๊ธฐ ๐
์ถฉ๋ถํ ์๊ฐ ๋์ ํ๋กํ์ผ๋ง์ ์คํํ์ธ์. ์งง์ ์๊ฐ์ผ๋ก๋ ๋ฌธ์ ๋ฅผ ์ฐพ๊ธฐ ์ด๋ ค์์.
Step 5: ๋ฐ์ดํฐ ๋ถ์ํ๊ธฐ ๐ฌ
์์ง๋ ๋ฐ์ดํฐ๋ฅผ ๊ผผ๊ผผํ ๋ถ์ํ์ธ์. ํจํด์ ์ฐพ๊ณ , ์ด์ํ ๋ถ๋ถ์ ์ฃผ๋ชฉํ์ธ์.
Step 6: ์ต์ ํ ๊ตฌํํ๊ธฐ โก
๋ฌธ์ ๋ฅผ ์ฐพ์๋ค๋ฉด ์ฝ๋๋ฅผ ์์ ํ์ธ์. ํ ๋ฒ์ ํ๋์ฉ ์์ ํ๋ ๊ฒ ์ข์์.
Step 7: ํจ๊ณผ ๊ฒ์ฆํ๊ธฐ โ
๋ค์ ํ๋กํ์ผ๋งํด์ ๊ฐ์ ํจ๊ณผ๋ฅผ ํ์ธํ์ธ์. ์ซ์๋ก ์ฆ๋ช
ํ ์ ์์ด์ผ ํด์!
Step 8: ๋ฐ๋ณตํ๊ธฐ ๐
๋ง์กฑ์ค๋ฌ์ด ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ๋๊น์ง ๋ฐ๋ณตํ์ธ์.
์ค์ ํ๋ก์ ํธ์์ ์ฌ์ฉํ ์ฒดํฌ๋ฆฌ์คํธ๋ฅผ ๊ณต์ ํ ๊ฒ์:
โ
์ฑ๋ฅ ์ต์ ํ ์ฒดํฌ๋ฆฌ์คํธ
์ฑ ์์ ์๊ฐ
โ ๋ถํ์ํ ์ด๊ธฐํ ์ฝ๋ ์ ๊ฑฐ
โ ์ง์ฐ ๋ก๋ฉ(Lazy Loading) ์ ์ฉ
โ ์คํ๋์ ํ๋ฉด ์ต์ ํ
๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ
โ ๋ฉ๋ชจ๋ฆฌ ๋์ ํ์ธ ๋ฐ ์์
โ ์ด๋ฏธ์ง ์บ์ ํฌ๊ธฐ ์ ํ
โ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ง์
์ ๋ฆฌ์์ค ํด์
UI ์ฑ๋ฅ
โ 60fps ์ ์ง ํ์ธ
โ ์คํ์คํฌ๋ฆฐ ๋ ๋๋ง ์ ๊ฑฐ
โ ์ด๋ฏธ์ง ํฌ๊ธฐ ์ต์ ํ
โ ํ
์ด๋ธ๋ทฐ/์ปฌ๋ ์
๋ทฐ ์คํฌ๋กค ์ต์ ํ
๋คํธ์ํฌ
โ ์์ฒญ ํ์ ์ต์ํ
โ ์บ์ฑ ์ ๋ต ๊ตฌํ
โ ํ์์์ ์ค์
โ ์คํ๋ผ์ธ ๋ชจ๋ ์ง์
๋ฐฐํฐ๋ฆฌ
โ ์์น ์๋น์ค ์ต์ ํ
โ ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ต์ํ
โ ๋ถํ์ํ ์ผ์ ์ฌ์ฉ ์ค์ง
ํ๋กํ์ผ๋งํ ๋ ๊ผญ ๊ธฐ์ตํด์ผ ํ ํ๋ค์ด์์:
๐ก ํ๋กํ์ผ๋ง ๊ฟํ
1. ์ค์ ๋๋ฐ์ด์ค์์ ํ
์คํธํ์ธ์
์๋ฎฌ๋ ์ดํฐ๋ Mac์ ์ฑ๋ฅ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ค์ ์ฑ๋ฅ์ ๋ฐ์ํ์ง ๋ชปํด์. ํนํ ์ค๋๋ ๋๋ฐ์ด์ค์์ ํ
์คํธํ๋ ๊ฒ ์ค์ํด์!
2. Release ๋น๋๋ก ํ
์คํธํ์ธ์
Debug ๋น๋๋ ์ต์ ํ๊ฐ ๋์ด ์์ง ์์์. ์ค์ ์ฌ์ฉ์๊ฐ ๊ฒฝํํ ์ฑ๋ฅ์ ๋ณด๋ ค๋ฉด Release ๋น๋๋ฅผ ์ฌ์ฉํ์ธ์.
3. ์ฌ๋ฌ ์๋๋ฆฌ์ค๋ฅผ ํ
์คํธํ์ธ์
๋ค์ํ ์ํฉ(๋คํธ์ํฌ ๋๋ฆผ, ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ, ๋ฐฐํฐ๋ฆฌ ๋ถ์กฑ ๋ฑ)์์ ํ
์คํธํด๋ณด์ธ์.
4. ๋ฒ ์ด์ค๋ผ์ธ์ ์ค์ ํ์ธ์
์ต์ ํ ์ ์ ์ฑ๋ฅ ์งํ๋ฅผ ๊ธฐ๋กํด๋์ธ์. ๊ฐ์ ํจ๊ณผ๋ฅผ ์ธก์ ํ ์ ์์ด์.
5. ์๋ํ๋ ์ฑ๋ฅ ํ
์คํธ๋ฅผ ๊ตฌ์ถํ์ธ์
XCTest๋ฅผ ์ฌ์ฉํด์ ์ฑ๋ฅ ํ
์คํธ๋ฅผ ์๋ํํ ์ ์์ด์.
import XCTest
class PerformanceTests: XCTestCase {
// โ
์ฑ๋ฅ ํ
์คํธ ์์
func testImageProcessingPerformance() {
let image = UIImage(named: "test_image")!
measure {
// ์ด ๋ธ๋ก์ ์คํ ์๊ฐ์ ์ธก์
_ = ImageProcessor.applyFilter(to: image)
}
// Xcode๊ฐ ์๋์ผ๋ก ํ๊ท ์คํ ์๊ฐ, ํ์ค ํธ์ฐจ ๋ฑ์ ๋ณด์ฌ์ค์
}
func testNetworkRequestPerformance() {
let expectation = self.expectation(description: "Network request")
measure {
NetworkManager.shared.fetchData { result in
expectation.fulfill()
}
waitForExpectations(timeout: 10)
}
}
func testTableViewScrollPerformance() {
let tableView = UITableView()
// ํ
์ด๋ธ๋ทฐ ์ค์ ...
measure {
// ์คํฌ๋กค ์๋ฎฌ๋ ์ด์
for i in 0..<100 {
let indexPath = IndexPath(row: i, section: 0)
_ = tableView.cellForRow(at: indexPath)
}
}
}
}
์ฌ๋ฅ๋ท(https://www.jaenung.net)์์ iOS ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ๊ฑฐ๋ ๋ฐฐ์ธ ์ ์๋ค๋ ๊ฑฐ ์๊ณ ๊ณ์ จ๋์? ์ฑ๋ฅ ์ต์ ํ ๊ฐ์ ์ ๋ฌธ ์ง์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ๋๋๋ฉด์ ํจ๊ป ์ฑ์ฅํ ์ ์์ด์! ๐ฑ
๐ ๊ณ ๊ธ ์ต์ ํ ๊ธฐ๋ฒ
๊ธฐ๋ณธ์ ๋์ด์ ๋ ๊น์ด ๋ค์ด๊ฐ๋ณผ๊น์? ๊ณ ๊ธ ๊ฐ๋ฐ์๋ค์ด ์ฌ์ฉํ๋ ์ต์ ํ ๊ธฐ๋ฒ๋ค์ ์๊ฐํ ๊ฒ์! ๐
โก ๋ฉํฐ์ค๋ ๋ฉ ์ต์ ํ
ํ๋ iOS ๋๋ฐ์ด์ค๋ ์ฌ๋ฌ ๊ฐ์ CPU ์ฝ์ด๋ฅผ ๊ฐ์ง๊ณ ์์ด์. ์ด๋ฅผ ํจ๊ณผ์ ์ผ๋ก ํ์ฉํ๋ฉด ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ฃ !
import Foundation
// โ
GCD(Grand Central Dispatch) ํ์ฉ
class DataProcessor {
// ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ก ์ฑ๋ฅ ํฅ์
func processLargeDataSet(_ items: [DataItem]) -> [ProcessedItem] {
let queue = DispatchQueue(
label: "com.app.processing",
qos: .userInitiated,
attributes: .concurrent
)
var results: [ProcessedItem] = []
let group = DispatchGroup()
let lock = NSLock()
for item in items {
group.enter()
queue.async {
let processed = self.process(item)
// ์ค๋ ๋ ์์ ํ๊ฒ ๊ฒฐ๊ณผ ์ถ๊ฐ
lock.lock()
results.append(processed)
lock.unlock()
group.leave()
}
}
group.wait()
return results
}
// โ
Operation Queue ํ์ฉ (๋ ์ธ๋ฐํ ์ ์ด)
func processWithDependencies(_ items: [DataItem]) {
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 4 // ๋์ ์คํ ์ ํ
var operations: [Operation] = []
for item in items {
let operation = BlockOperation {
self.process(item)
}
// ์์กด์ฑ ์ค์ (์์ ๋ณด์ฅ)
if let lastOp = operations.last {
operation.addDependency(lastOp)
}
operations.append(operation)
operationQueue.addOperation(operation)
}
// ๋ชจ๋ ์์
์๋ฃ ๋๊ธฐ
operationQueue.waitUntilAllOperationsAreFinished()
}
private func process(_ item: DataItem) -> ProcessedItem {
// ๋ฌด๊ฑฐ์ด ์ฒ๋ฆฌ ์์
return ProcessedItem(from: item)
}
}
// โ
Actor๋ฅผ ์ฌ์ฉํ ์ค๋ ๋ ์์ ์ฑ (Swift 5.5+)
actor SafeCounter {
private var value = 0
func increment() {
value += 1
}
func getValue() -> Int {
return value
}
}
// ์ฌ์ฉ ์์
Task {
let counter = SafeCounter()
await withTaskGroup(of: Void.self) { group in
for _ in 0..<1000 {
group.addTask {
await counter.increment()
}
}
}
let finalValue = await counter.getValue()
print("Final count: \(finalValue)") // ํญ์ 1000
}
๐จ Metal์ ํ์ฉํ GPU ๊ฐ์
๋ณต์กํ ๊ทธ๋ํฝ ์ฒ๋ฆฌ๋ ์ด๋ฏธ์ง ํํฐ๋ง์ GPU๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์ฌ ๋นจ๋ผ์!
import Metal
import MetalKit
class MetalImageProcessor {
let device: MTLDevice
let commandQueue: MTLCommandQueue
let pipelineState: MTLComputePipelineState
init?() {
// Metal ๋๋ฐ์ด์ค ์ด๊ธฐํ
guard let device = MTLCreateSystemDefaultDevice(),
let commandQueue = device.makeCommandQueue() else {
return nil
}
self.device = device
self.commandQueue = commandQueue
// ์
ฐ์ด๋ ํจ์ ๋ก๋
guard let library = device.makeDefaultLibrary(),
let kernelFunction = library.makeFunction(name: "blurKernel"),
let pipelineState = try? device.makeComputePipelineState(function: kernelFunction) else {
return nil
}
self.pipelineState = pipelineState
}
// GPU๋ฅผ ์ฌ์ฉํ ์ด๋ฏธ์ง ๋ธ๋ฌ ์ฒ๋ฆฌ
func applyBlur(to image: UIImage) -> UIImage? {
guard let cgImage = image.cgImage else { return nil }
// ํ
์ค์ฒ ์์ฑ
let textureLoader = MTKTextureLoader(device: device)
guard let inputTexture = try? textureLoader.newTexture(cgImage: cgImage) else {
return nil
}
// ์ถ๋ ฅ ํ
์ค์ฒ ์์ฑ
let descriptor = MTLTextureDescriptor.texture2DDescriptor(
pixelFormat: inputTexture.pixelFormat,
width: inputTexture.width,
height: inputTexture.height,
mipmapped: false
)
descriptor.usage = [.shaderWrite, .shaderRead]
guard let outputTexture = device.makeTexture(descriptor: descriptor) else {
return nil
}
// ์ปค๋งจ๋ ๋ฒํผ ์์ฑ ๋ฐ ์คํ
guard let commandBuffer = commandQueue.makeCommandBuffer(),
let computeEncoder = commandBuffer.makeComputeCommandEncoder() else {
return nil
}
computeEncoder.setComputePipelineState(pipelineState)
computeEncoder.setTexture(inputTexture, index: 0)
computeEncoder.setTexture(outputTexture, index: 1)
// ์ค๋ ๋ ๊ทธ๋ฃน ์ค์
let threadGroupSize = MTLSize(width: 16, height: 16, depth: 1)
let threadGroups = MTLSize(
width: (inputTexture.width + 15) / 16,
height: (inputTexture.height + 15) / 16,
depth: 1
)
computeEncoder.dispatchThreadgroups(threadGroups, threadsPerThreadgroup: threadGroupSize)
computeEncoder.endEncoding()
commandBuffer.commit()
commandBuffer.waitUntilCompleted()
// ๊ฒฐ๊ณผ๋ฅผ UIImage๋ก ๋ณํ
return convertTextureToImage(outputTexture)
}
private func convertTextureToImage(_ texture: MTLTexture) -> UIImage? {
// ํ
์ค์ฒ๋ฅผ ์ด๋ฏธ์ง๋ก ๋ณํํ๋ ๋ก์ง
// ์ค์ ๊ตฌํ์ ๋ ๋ณต์กํด์
return nil
}
}
๐ฏ Metal vs CPU ์ฑ๋ฅ ๋น๊ต
์ค์ ํ
์คํธ ๊ฒฐ๊ณผ, ๋ณต์กํ ์ด๋ฏธ์ง ํํฐ ์ฒ๋ฆฌ์์:
โข CPU ์ฒ๋ฆฌ: ์ฝ 500ms
โข Metal(GPU) ์ฒ๋ฆฌ: ์ฝ 50ms
10๋ฐฐ ์ด์ ๋น ๋ฅธ ์ฑ๋ฅ! ๐
ํ์ง๋ง ๊ฐ๋จํ ์์
์๋ CPU๊ฐ ๋ ํจ์จ์ ์ผ ์ ์์ด์. GPU๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ์ค๋ฒํค๋๊ฐ ์๊ฑฐ๋ ์.
๐ฆ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ต์ ํ
์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ ํํ๋ ๊ฒ๋ง์ผ๋ก๋ ์ฑ๋ฅ์ด ํฌ๊ฒ ํฅ์๋ ์ ์์ด์!
// โ ๋นํจ์จ์ : Array์์ ๊ฒ์ (O(n))
class UserManager {
var users: [User] = []
func findUser(byId id: String) -> User? {
return users.first { $0.id == id } // ๋๋ฆผ!
}
}
// โ
ํจ์จ์ : Dictionary ์ฌ์ฉ (O(1))
class UserManager {
var users: [String: User] = [:] // ID๋ฅผ ํค๋ก ์ฌ์ฉ
func findUser(byId id: String) -> User? {
return users[id] // ๋น ๋ฆ!
}
}
// โ
Set์ ํ์ฉํ ์ค๋ณต ์ ๊ฑฐ
class TagManager {
var tags: Set<String> = [] // ์๋์ผ๋ก ์ค๋ณต ์ ๊ฑฐ
func addTag(_ tag: String) {
tags.insert(tag) // O(1)
}
func hasTag(_ tag: String) -> Bool {
return tags.contains(tag) // O(1)
}
}
// โ
์ ๋ ฌ๋ ๋ฐ์ดํฐ์์ ์ด์ง ๊ฒ์
extension Array where Element: Comparable {
func binarySearch(_ target: Element) -> Int? {
var left = 0
var right = count - 1
while left <= right {
let mid = (left + right) / 2
let midValue = self[mid]
if midValue == target {
return mid
} else if midValue < target {
left = mid + 1
} else {
right = mid - 1
}
}
return nil
}
}
// ์ฌ์ฉ ์์
let sortedNumbers = [1, 3, 5, 7, 9, 11, 13, 15]
if let index = sortedNumbers.binarySearch(7) {
print("Found at index: \(index)") // O(log n) - ๋งค์ฐ ๋น ๋ฆ!
}
๐ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ฑ๋ฅ ๋น๊ต
๊ฒ์ ์ฑ๋ฅ:
โข Array: O(n) - ์ ํ ๊ฒ์
โข Dictionary: O(1) - ํด์ ํ
์ด๋ธ
โข Set: O(1) - ํด์ ํ
์ด๋ธ
โข ์ ๋ ฌ๋ Array + ์ด์ง ๊ฒ์: O(log n)
์ฝ์
์ฑ๋ฅ:
โข Array (๋): O(1)
โข Array (์ค๊ฐ): O(n)
โข Dictionary: O(1)
โข Set: O(1)
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ:
โข Array: ๊ฐ์ฅ ํจ์จ์
โข Dictionary: Array๋ณด๋ค ๋ง์
โข Set: Dictionary์ ๋น์ท
๐ Lazy Loading๊ณผ Pagination
๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ๋ก๋ํ์ง ๋ง๊ณ , ํ์ํ ๋ ํ์ํ ๋งํผ๋ง ๋ก๋ํ์ธ์!
// โ
Lazy ํ๋กํผํฐ ํ์ฉ
class ExpensiveResource {
// ์ค์ ๋ก ์ฌ์ฉ๋ ๋๊น์ง ์ด๊ธฐํ๋์ง ์์
lazy var heavyObject: HeavyObject = {
print("Initializing heavy object...")
return HeavyObject()
}()
lazy var processedData: [ProcessedItem] = {
return self.rawData.map { self.process($0) }
}()
var rawData: [RawItem] = []
}
// โ
๋ฌดํ ์คํฌ๋กค ๊ตฌํ
class InfiniteScrollViewController: UIViewController, UITableViewDelegate {
var items: [Item] = []
var currentPage = 0
var isLoading = false
var hasMoreData = true
func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
// ๋ง์ง๋ง ์
์ ๋๋ฌํ๋ฉด ๋ค์ ํ์ด์ง ๋ก๋
if indexPath.row == items.count - 1 && !isLoading && hasMoreData {
loadNextPage()
}
}
func loadNextPage() {
guard !isLoading else { return }
isLoading = true
APIClient.fetchItems(page: currentPage, limit: 20) { [weak self] result in
guard let self = self else { return }
self.isLoading = false
switch result {
case .success(let newItems):
if newItems.isEmpty {
self.hasMoreData = false
} else {
let startIndex = self.items.count
self.items.append(contentsOf: newItems)
self.currentPage += 1
// ์๋ก์ด ์
๋ง ์
๋ฐ์ดํธ
let indexPaths = (startIndex..<self.items.count).map {
IndexPath(row: $0, section: 0)
}
self.tableView.insertRows(at: indexPaths, with: .automatic)
}
case .failure(let error):
self.showError(error)
}
}
}
}
// โ
์ด๋ฏธ์ง ๋ ์ด์ง ๋ก๋ฉ
class LazyImageView: UIImageView {
private var imageURL: URL?
private var loadTask: URLSessionDataTask?
func loadImage(from url: URL) {
// ์ด์ ์์
์ทจ์
loadTask?.cancel()
imageURL = url
// ์บ์ ํ์ธ
if let cachedImage = ImageCache.shared.getImage(forKey: url.absoluteString) {
self.image = cachedImage
return
}
// ํ๋ ์ด์คํ๋ ํ์
self.image = UIImage(named: "placeholder")
// ๋น๋๊ธฐ ๋ก๋
loadTask = URLSession.shared.dataTask(with: url) { [weak self] data, _, error in
guard let self = self,
let data = data,
let image = UIImage(data: data),
self.imageURL == url else { return }
// ์บ์์ ์ ์ฅ
ImageCache.shared.setImage(image, forKey: url.absoluteString)
DispatchQueue.main.async {
self.image = image
}
}
loadTask?.resume()
}
// ์
์ด ์ฌ์ฌ์ฉ๋ ๋ ํธ์ถ
func cancelLoading() {
loadTask?.cancel()
loadTask = nil
}
}
์ด๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ ์ ์ ํ ํ์ฉํ๋ฉด ์ฑ์ ์ฑ๋ฅ์ ๊ทน๋ํํ ์ ์์ด์! ํ์ง๋ง ํญ์ ๊ธฐ์ตํ์ธ์: "์กฐ๊ธฐ ์ต์ ํ๋ ๋ง์ ์ ๊ทผ์"์ด๋ผ๋ ๋ง์ด ์์ด์. ๋จผ์ ๋์ํ๋ ์ฝ๋๋ฅผ ๋ง๋ค๊ณ , ํ๋กํ์ผ๋ง์ผ๋ก ๋ณ๋ชฉ ์ง์ ์ ์ฐพ์ ๋ค์, ๊ทธ ๋ถ๋ถ๋ง ์ต์ ํํ๋ ๊ฒ ํ๋ช ํ ์ ๊ทผ์ด์์. ๐ฏ
๐ผ ์ค์ ์ฌ๋ก ์ฐ๊ตฌ
์ด๋ก ๋ ์ค์ํ์ง๋ง, ์ค์ ์ฌ๋ก๋ฅผ ํตํด ๋ฐฐ์ฐ๋ ๊ฒ ๊ฐ์ฅ ํจ๊ณผ์ ์ด์ฃ ! ์ ๊ฐ ๊ฒฝํํ ์ค์ ํ๋ก์ ํธ ์ฌ๋ก๋ค์ ๊ณต์ ํ ๊ฒ์. ๐
๐ฎ ์ฌ๋ก 1: ๊ฒ์ ์ฑ ํ๋ ์ ๋๋กญ ํด๊ฒฐ
๋ฌธ์ ์ํฉ:
์บ์ฃผ์ผ ํผ์ฆ ๊ฒ์์์ ํน์ ๋ ๋ฒจ์์ ํ๋ ์์ด 30fps ์ดํ๋ก ๋จ์ด์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ด์. ์ฌ์ฉ์๋ค์ด "๊ฒ์์ด ๋ฒ๋ฒ
๊ฑฐ๋ฆฐ๋ค"๋ ๋ถ๋ง์ ์ ๊ธฐํ์ฃ .
๋ถ์ ๊ณผ์ :
Time Profiler๋ก ๋ถ์ํ ๊ฒฐ๊ณผ, ๋งค ํ๋ ์๋ง๋ค ๋ชจ๋ ๊ฒ์ ์ค๋ธ์ ํธ์ ์ถฉ๋ ๊ฒ์ฌ๋ฅผ ํ๊ณ ์์์ด์. 100๊ฐ์ ์ค๋ธ์ ํธ๊ฐ ์์ผ๋ฉด 10,000๋ฒ์ ๊ฒ์ฌ๊ฐ ํ์ํ์ฃ ! (O(nยฒ) ๋ณต์ก๋)
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ๊ณต๊ฐ ๋ถํ (Spatial Partitioning) ์๊ณ ๋ฆฌ์ฆ ๋์
โข ํ๋ฉด์ ๊ทธ๋ฆฌ๋๋ก ๋๋์ด ์ธ์ ํ ์
์ ์ค๋ธ์ ํธ๋ง ๊ฒ์ฌ
โข ์ถฉ๋ ๊ฒ์ฌ ํ์๊ฐ 100๋ฐฐ ์ด์ ๊ฐ์!
๊ฒฐ๊ณผ:
ํ๋ ์์ด ์์ ์ ์ผ๋ก 60fps๋ฅผ ์ ์งํ๊ฒ ๋์๊ณ , ์ฑ์คํ ์ด ํ์ ์ด 3.2์์ 4.5๋ก ์์นํ์ด์! โญโญโญโญโญ
๐ธ ์ฌ๋ก 2: ์ฌ์ง ์ฑ ๋ฉ๋ชจ๋ฆฌ ํฌ๋์ ํด๊ฒฐ
๋ฌธ์ ์ํฉ:
์ฌ์ฉ์๊ฐ ์ฌ๋ฌ ์ฅ์ ๊ณ ํด์๋ ์ฌ์ง์ ํธ์งํ ๋ ์ฑ์ด ์์ฃผ ํฌ๋์๋๋ ๋ฌธ์ ๊ฐ ์์์ด์. ํนํ iPhone 7 ๊ฐ์ ๊ตฌํ ๊ธฐ๊ธฐ์์ ์ฌ๊ฐํ์ฃ .
๋ถ์ ๊ณผ์ :
Allocations ๋๊ตฌ๋ก ํ์ธํด๋ณด๋, 12MP ์ฌ์ง ํ๋๊ฐ ์ฝ 48MB์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ ์์์ด์. 10์ฅ๋ง ์ด์ด๋ 480MB! iOS๋ ์ฑ์ ์ ํ๋ ๋ฉ๋ชจ๋ฆฌ๋ง ํ ๋นํ๊ธฐ ๋๋ฌธ์ ํฌ๋์๊ฐ ๋ฐ์ํ ๊ฑฐ์์.
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข ํ๋ฉด์ ํ์ํ ๋๋ ๋ค์ด์ํ๋ง๋ ์ด๋ฏธ์ง ์ฌ์ฉ
โข ์ค์ ํธ์ง ์์๋ง ์๋ณธ ์ด๋ฏธ์ง ๋ก๋
โข ํธ์ง ์๋ฃ ํ ์ฆ์ ๋ฉ๋ชจ๋ฆฌ ํด์
โข NSCache๋ฅผ ์ฌ์ฉํ ์ง๋ฅ์ ์บ์ฑ
๊ฒฐ๊ณผ:
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด 70% ๊ฐ์ํ๊ณ , ํฌ๋์์จ์ด 5%์์ 0.1%๋ก ๋จ์ด์ก์ด์! ๐
// ์ฌ์ง ์ฑ ๋ฉ๋ชจ๋ฆฌ ์ต์ ํ ์ฝ๋
class PhotoEditor {
// โ
๋ค์ด์ํ๋ง์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ
func loadThumbnail(from url: URL, targetSize: CGSize) -> UIImage? {
let options = [
kCGImageSourceCreateThumbnailWithTransform: true,
kCGImageSourceCreateThumbnailFromImageAlways: true,
kCGImageSourceThumbnailMaxPixelSize: max(targetSize.width, targetSize.height)
] as CFDictionary
guard let imageSource = CGImageSourceCreateWithURL(url as CFURL, nil),
let cgImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options) else {
return nil
}
return UIImage(cgImage: cgImage)
}
// โ
ํ์ํ ๋๋ง ์๋ณธ ๋ก๋
func loadFullResolution(from url: URL, completion: @escaping (UIImage?) -> Void) {
DispatchQueue.global(qos: .userInitiated).async {
guard let image = UIImage(contentsOfFile: url.path) else {
DispatchQueue.main.async {
completion(nil)
}
return
}
DispatchQueue.main.async {
completion(image)
}
}
}
// โ
ํธ์ง ์๋ฃ ํ ๋ฉ๋ชจ๋ฆฌ ์ ๋ฆฌ
func finishEditing() {
// ์๋ณธ ์ด๋ฏธ์ง ํด์
fullResolutionImage = nil
// ํธ์ง ํ์คํ ๋ฆฌ ์ ๋ฆฌ
editHistory.removeAll()
// ์์ ํ์ผ ์ญ์
cleanupTempFiles()
// ๋ช
์์ ๋ฉ๋ชจ๋ฆฌ ํด์ ์์ฒญ
autoreleasepool {
// ๋ฉ๋ชจ๋ฆฌ ์ง์ฝ์ ์์
์ ๋ฆฌ
}
}
}
๐ ์ฌ๋ก 3: ํผํธ๋์ค ์ฑ ๋ฐฐํฐ๋ฆฌ ์ต์ ํ
๋ฌธ์ ์ํฉ:
์ด๋ ์ถ์ ์ฑ์ด 1์๊ฐ ์ฌ์ฉ ์ ๋ฐฐํฐ๋ฆฌ๋ฅผ 40%๋ ์๋ชจํ์ด์. ์ฌ์ฉ์๋ค์ด "๋ฐฐํฐ๋ฆฌ ํฌ๋ฌ"๋ผ๊ณ ๋ถํํ์ฃ .
๋ถ์ ๊ณผ์ :
Energy Log๋ก ๋ถ์ํ ๊ฒฐ๊ณผ:
โข GPS๋ฅผ ์ต๊ณ ์ ํ๋๋ก 1์ด๋ง๋ค ์
๋ฐ์ดํธ
โข ๋ฐฑ๊ทธ๋ผ์ด๋์์๋ ๊ณ์ ์์น ์ถ์
โข ์ค์๊ฐ์ผ๋ก ์๋ฒ์ ๋ฐ์ดํฐ ์ ์ก
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข GPS ์ ํ๋๋ฅผ ์ํฉ์ ๋ง๊ฒ ์กฐ์
โข ์์น ์
๋ฐ์ดํธ ๊ฐ๊ฒฉ์ 10์ด๋ก ์ฆ๊ฐ
โข ๋ฐ์ดํฐ๋ฅผ ๋ก์ปฌ์ ์ ์ฅ ํ ๋ฐฐ์น๋ก ์ ์ก
โข ์ฌ์ฉ์๊ฐ ๋ฉ์ถฐ์์ ๋ ์๋์ผ๋ก ์ผ์์ ์ง
๊ฒฐ๊ณผ:
๋ฐฐํฐ๋ฆฌ ์๋ชจ๊ฐ 40%์์ 15%๋ก ๊ฐ์! ์ฌ์ฉ์๋ค์ด "์ด์ ํ๋ฃจ ์ข
์ผ ์ฌ์ฉํ ์ ์์ด์!"๋ผ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋จ๊ฒผ์ด์. ๐ช๐
์ฌ๋ฅ๋ท์์๋ ์ด๋ฐ ์ค์ ๊ฒฝํ์ ๊ฐ์ง ๊ฐ๋ฐ์๋ค๊ณผ ์ง์ ์ํตํ๋ฉฐ ๋ฐฐ์ธ ์ ์์ด์. ์ฑ๋ฅ ์ต์ ํ ๊ฐ์ ๊ณ ๊ธ ๊ธฐ์ ์ ์ค์ ํ๋ก์ ํธ ๊ฒฝํ์ด ์ ๋ง ์ค์ํ๊ฑฐ๋ ์! ๐
๐ฏ ์ฑ๋ฅ ์ต์ ํ ๋ฒ ์คํธ ํ๋ํฐ์ค
์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ์ ๋ฆฌํด์, ์ค๋ฌด์์ ๋ฐ๋ก ์ ์ฉํ ์ ์๋ ๋ฒ ์คํธ ํ๋ํฐ์ค๋ฅผ ์ ๋ฆฌํด๋ณผ๊ฒ์! ๐
๐ ์ฑ๋ฅ ์ต์ ํ ํฉ๊ธ ๊ท์น
1. ์ธก์ ํ์ง ์์ผ๋ฉด ์ต์ ํํ์ง ๋ง๋ผ
์ถ์ธก์ผ๋ก ์ต์ ํํ์ง ๋ง๊ณ , ํญ์ ํ๋กํ์ผ๋ง ๋๊ตฌ๋ก ์ธก์ ํ์ธ์. ์์๊ณผ ๋ค๋ฅธ ๊ณณ์ด ๋ณ๋ชฉ์ผ ์ ์์ด์!
2. ์ฌ์ฉ์ ๊ฒฝํ์ ์ต์ฐ์ ์ผ๋ก
๊ธฐ์ ์ ์ผ๋ก ์๋ฒฝํด๋ ์ฌ์ฉ์๊ฐ ๋๋ผ์ง ๋ชปํ๋ฉด ์๋ฏธ๊ฐ ์์ด์. ์ฒด๊ฐ ์ฑ๋ฅ์ ๊ฐ์ ํ์ธ์.
3. ์กฐ๊ธฐ ์ต์ ํ๋ ํผํ๋ผ
๋จผ์ ๋์ํ๋ ์ฝ๋๋ฅผ ๋ง๋ค๊ณ , ๋ฌธ์ ๊ฐ ์์ ๋ ์ต์ ํํ์ธ์. ์๊ฐ ๋ญ๋น๋ฅผ ์ค์ผ ์ ์์ด์.
4. 80/20 ๋ฒ์น์ ๊ธฐ์ตํ๋ผ
์ ์ฒด ์ฑ๋ฅ ๋ฌธ์ ์ 80%๋ ์ฝ๋์ 20%์์ ๋ฐ์ํด์. ๊ทธ 20%๋ฅผ ์ฐพ์์ ์ง์คํ์ธ์!
5. ์ง์์ ์ผ๋ก ๋ชจ๋ํฐ๋งํ๋ผ
ํ ๋ฒ ์ต์ ํํ๊ณ ๋์ด ์๋์์. ์๋ก์ด ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ๋๋ง๋ค ์ฑ๋ฅ์ ์ฒดํฌํ์ธ์.
โ
์ผ์ผ ๊ฐ๋ฐ ์ฒดํฌ๋ฆฌ์คํธ
์ฝ๋ ์์ฑ ์:
โ ๋ฉ์ธ ์ค๋ ๋์์ ๋ฌด๊ฑฐ์ด ์์
ํ์ง ์๊ธฐ
โ ํด๋ก์ ์์ [weak self] ์ฌ์ฉํ๊ธฐ
โ ๋ถํ์ํ ๊ฐ์ฒด ์์ฑ ํผํ๊ธฐ
โ ์ ์ ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ ํํ๊ธฐ
UI ์์
์:
โ ์ด๋ฏธ์ง ํฌ๊ธฐ ์ต์ ํํ๊ธฐ
โ ๋ถํฌ๋ช
๋ทฐ๋ isOpaque = true ์ค์
โ ์คํ์คํฌ๋ฆฐ ๋ ๋๋ง ํผํ๊ธฐ
โ ์
์ฌ์ฌ์ฉ ์ ๋๋ก ๊ตฌํํ๊ธฐ
๋คํธ์ํฌ ์์
์:
โ ์์ฒญ ํ์ ์ต์ํํ๊ธฐ
โ ์บ์ฑ ์ ๋ต ๊ตฌํํ๊ธฐ
โ ํ์์์ ์ค์ ํ๊ธฐ
โ ์๋ฌ ์ฒ๋ฆฌ ์ ๋๋ก ํ๊ธฐ
๋ฆด๋ฆฌ์ฆ ์ :
โ ์ค์ ๋๋ฐ์ด์ค์์ ํ
์คํธ
โ Release ๋น๋๋ก ํ๋กํ์ผ๋ง
โ ๋ฉ๋ชจ๋ฆฌ ๋์ ์ฒดํฌ
โ ๋ฐฐํฐ๋ฆฌ ์๋ชจ ํ
์คํธ
๐ก ์ฑ๋ฅ ์ต์ ํ ๋๊ตฌ ๋ชจ์
Apple ๊ณต์ ๋๊ตฌ:
โข Instruments - ์ข
ํฉ ํ๋กํ์ผ๋ง ๋๊ตฌ
โข Xcode Organizer - ํฌ๋์ ๋ฆฌํฌํธ ๋ถ์
โข MetricKit - ์ค์ ์ฌ์ฉ์ ๋ฐ์ดํฐ ์์ง
โข Network Link Conditioner - ๋คํธ์ํฌ ์๋ฎฌ๋ ์ด์
์๋ํํฐ ๋๊ตฌ:
โข Firebase Performance Monitoring - ์ค์๊ฐ ์ฑ๋ฅ ๋ชจ๋ํฐ๋ง
โข New Relic - APM(Application Performance Monitoring)
โข Instabug - ์ฑ๋ฅ ์ด์ ๋ฆฌํฌํ
โข Charles Proxy - ๋คํธ์ํฌ ๋๋ฒ๊น
์ฝ๋ ํ์ง ๋๊ตฌ:
โข SwiftLint - ์ฝ๋ ์คํ์ผ ๊ฒ์ฌ
โข SonarQube - ์ฝ๋ ํ์ง ๋ถ์
โข Periphery - ์ฌ์ฉํ์ง ์๋ ์ฝ๋ ์ฐพ๊ธฐ
// โ
์ฑ๋ฅ ๋ชจ๋ํฐ๋ง ํฌํผ ํด๋์ค
import Foundation
class PerformanceMonitor {
static let shared = PerformanceMonitor()
// ํจ์ ์คํ ์๊ฐ ์ธก์
func measure<T>(_ name: String, block: () -> T) -> T {
let start = CFAbsoluteTimeGetCurrent()
let result = block()
let end = CFAbsoluteTimeGetCurrent()
let duration = (end - start) * 1000 // ms๋ก ๋ณํ
print("โฑ๏ธ [\(name)] took \(String(format: "%.2f", duration))ms")
// ๋๋ฌด ์ค๋ ๊ฑธ๋ฆฌ๋ฉด ๊ฒฝ๊ณ
if duration > 100 {
print("โ ๏ธ Warning: \(name) is taking too long!")
}
return result
}
// ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฒดํฌ
func checkMemoryUsage() {
var info = mach_task_basic_info()
var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
$0.withMemoryRebound(to: integer_t.self, capacity: 1) {
task_info(mach_task_self_,
task_flavor_t(MACH_TASK_BASIC_INFO),
$0,
&count)
}
}
if kerr == KERN_SUCCESS {
let usedMB = Double(info.resident_size) / 1024.0 / 1024.0
print("๐พ Memory usage: \(String(format: "%.2f", usedMB))MB")
// ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ๋๋ฌด ๋์ผ๋ฉด ๊ฒฝ๊ณ
if usedMB > 200 {
print("โ ๏ธ Warning: High memory usage!")
}
}
}
// FPS ๋ชจ๋ํฐ๋ง
class FPSMonitor {
private var displayLink: CADisplayLink?
private var lastTimestamp: CFTimeInterval = 0
private var frameCount = 0
func start() {
displayLink = CADisplayLink(target: self, selector: #selector(tick))
displayLink?.add(to: .main, forMode: .common)
}
func stop() {
displayLink?.invalidate()
displayLink = nil
}
@objc private func tick(displayLink: CADisplayLink) {
if lastTimestamp == 0 {
lastTimestamp = displayLink.timestamp
return
}
frameCount += 1
let elapsed = displayLink.timestamp - lastTimestamp
if elapsed >= 1.0 {
let fps = Double(frameCount) / elapsed
print("๐ฌ FPS: \(String(format: "%.1f", fps))")
if fps < 55 {
print("โ ๏ธ Warning: Low FPS detected!")
}
frameCount = 0
lastTimestamp = displayLink.timestamp
}
}
}
}
// ์ฌ์ฉ ์์
let result = PerformanceMonitor.shared.measure("Heavy Calculation") {
// ๋ฌด๊ฑฐ์ด ๊ณ์ฐ ์์
return complexCalculation()
}
PerformanceMonitor.shared.checkMemoryUsage()
let fpsMonitor = PerformanceMonitor.FPSMonitor()
fpsMonitor.start() // FPS ๋ชจ๋ํฐ๋ง ์์
์ด๋ฐ ๋๊ตฌ๋ค์ ๊ฐ๋ฐ ๊ณผ์ ์ ํตํฉํ๋ฉด, ์ฑ๋ฅ ๋ฌธ์ ๋ฅผ ์กฐ๊ธฐ์ ๋ฐ๊ฒฌํ๊ณ ํด๊ฒฐํ ์ ์์ด์! ๐ฏ
๐ ๋ฏธ๋๋ฅผ ์ํ ์ค๋น: SwiftUI์ Async/Await
iOS ๊ฐ๋ฐ์ ๋ฏธ๋๋ SwiftUI์ Swift Concurrency(async/await)์์. ์ด ์๋ก์ด ๊ธฐ์ ๋ค๋ ์ฑ๋ฅ ์ต์ ํ ๊ด์ ์์ ์์๋ฌ์ผ ํ ๊ฒ ๋ง์์! ๐ฎ
โก SwiftUI ์ฑ๋ฅ ์ต์ ํ
import SwiftUI
// โ
@State์ @Binding ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๊ธฐ
struct ParentView: View {
@State private var items: [Item] = []
var body: some View {
List(items) { item in
// Binding์ ์ ๋ฌํ์ฌ ๋ถํ์ํ ์ฌ๋ ๋๋ง ๋ฐฉ์ง
ItemRow(item: $items[items.firstIndex(of: item)!])
}
}
}
// โ
EquatableView๋ก ๋ถํ์ํ ์
๋ฐ์ดํธ ๋ฐฉ์ง
struct ItemRow: View, Equatable {
@Binding var item: Item
var body: some View {
HStack {
Text(item.title)
Spacer()
Text("\(item.count)")
}
}
// ์ค์ ๋ก ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ์๋ง ์
๋ฐ์ดํธ
static func == (lhs: ItemRow, rhs: ItemRow) -> Bool {
lhs.item.id == rhs.item.id &&
lhs.item.title == rhs.item.title &&
lhs.item.count == rhs.item.count
}
}
// โ
LazyVStack/LazyHStack ์ฌ์ฉํ๊ธฐ
struct LargeListView: View {
let items: [Item]
var body: some View {
ScrollView {
// ํ๋ฉด์ ๋ณด์ด๋ ํญ๋ชฉ๋ง ๋ ๋๋ง
LazyVStack(spacing: 10) {
ForEach(items) { item in
ItemCard(item: item)
}
}
}
}
}
// โ
@StateObject vs @ObservedObject ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉ
class ViewModel: ObservableObject {
@Published var data: [Item] = []
func loadData() {
// ๋ฐ์ดํฐ ๋ก๋
}
}
struct ContentView: View {
// ๋ทฐ๊ฐ ์์ ํ๋ ๊ฒฝ์ฐ @StateObject
@StateObject private var viewModel = ViewModel()
var body: some View {
List(viewModel.data) { item in
// ์์ ๋ทฐ์ ์ ๋ฌํ ๋๋ @ObservedObject
DetailView(viewModel: viewModel)
}
}
}
// โ
๋ณต์กํ ๊ณ์ฐ์ ์บ์ฑํ๊ธฐ
struct ExpensiveView: View {
let data: [Double]
// ๊ณ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์บ์ฑ
private var processedData: [ProcessedItem] {
// ์ด ๊ณ์ฐ์ data๊ฐ ๋ณ๊ฒฝ๋ ๋๋ง ์คํ๋จ
data.map { ProcessedItem(value: $0) }
}
var body: some View {
List(processedData) { item in
Text("\(item.value)")
}
}
}
๐ Swift Concurrency ํ์ฉํ๊ธฐ
import Foundation
// โ
async/await๋ก ๊น๋ํ ๋น๋๊ธฐ ์ฝ๋
class DataService {
// ๊ธฐ์กด ์ฝ๋ฐฑ ๋ฐฉ์ (๋ณต์กํจ)
func fetchDataOld(completion: @escaping (Result<Data, Error>) -> Void) {
URLSession.shared.dataTask(with: url) { data, response, error in
if let error = error {
completion(.failure(error))
return
}
guard let data = data else {
completion(.failure(NetworkError.noData))
return
}
completion(.success(data))
}.resume()
}
// ์๋ก์ด async/await ๋ฐฉ์ (๊น๋ํจ)
func fetchData() async throws -> Data {
let (data, _) = try await URLSession.shared.data(from: url)
return data
}
// โ
๋ณ๋ ฌ ์ฒ๋ฆฌ๋ก ์ฑ๋ฅ ํฅ์
func fetchMultipleResources() async throws -> [Resource] {
// ์ฌ๋ฌ ์์ฒญ์ ๋์์ ์คํ
async let user = fetchUser()
async let posts = fetchPosts()
async let friends = fetchFriends()
// ๋ชจ๋ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ค๋ฆผ
return try await [user, posts, friends]
}
// โ
TaskGroup์ผ๋ก ๋์ ๋ณ๋ ฌ ์ฒ๋ฆฌ
func processItems(_ items: [Item]) async -> [ProcessedItem] {
await withTaskGroup(of: ProcessedItem.self) { group in
for item in items {
group.addTask {
return await self.process(item)
}
}
var results: [ProcessedItem] = []
for await result in group {
results.append(result)
}
return results
}
}
// โ
Actor๋ก ์ค๋ ๋ ์์ ์ฑ ๋ณด์ฅ
actor ImageCache {
private var cache: [String: UIImage] = [:]
func getImage(forKey key: String) -> UIImage? {
return cache[key]
}
func setImage(_ image: UIImage, forKey key: String) {
cache[key] = image
}
func clear() {
cache.removeAll()
}
}
// โ
AsyncSequence๋ก ์คํธ๋ฆฌ๋ฐ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
func streamData() -> AsyncStream<Data> {
AsyncStream { continuation in
let task = URLSession.shared.dataTask(with: url) { data, _, error in
if let data = data {
continuation.yield(data)
}
continuation.finish()
}
task.resume()
continuation.onTermination = { _ in
task.cancel()
}
}
}
}
// ์ฌ์ฉ ์์
Task {
do {
// ์์ฐจ ์คํ
let data = try await dataService.fetchData()
let processed = await processData(data)
// ๋ณ๋ ฌ ์คํ
let resources = try await dataService.fetchMultipleResources()
// ์คํธ๋ฆฌ๋ฐ
for await data in dataService.streamData() {
handleData(data)
}
} catch {
handleError(error)
}
}
๐ฏ async/await์ ์ฑ๋ฅ ์ด์
1. ๋ ์ ์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ
์ฝ๋ฐฑ ํด๋ก์ ๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ ์ด์์.
2. ๋ ๋์ ์ปดํ์ผ๋ฌ ์ต์ ํ
Swift ์ปดํ์ผ๋ฌ๊ฐ ๋ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด์.
3. ์๋ ์ค๋ ๋ ๊ด๋ฆฌ
๋ฐํ์์ด ์๋์ผ๋ก ์ต์ ์ ์ค๋ ๋๋ฅผ ์ ํํด์.
4. ์ทจ์ ์ฒ๋ฆฌ ๊ฐ์
Task ์ทจ์๊ฐ ๋ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌ๋ผ์.
์๋ก์ด ๊ธฐ์ ์ ๋ฐฐ์ฐ๋ ๊ฒ๋ ์ค์ํ์ง๋ง, ๊ธฐ๋ณธ ์๋ฆฌ๋ฅผ ์ดํดํ๋ ๊ฒ ๋ ์ค์ํด์. SwiftUI์ async/await๋ ๊ฒฐ๊ตญ ๊ฐ์ ์ฑ๋ฅ ์์น์ ๋ฐ๋ฅด๊ฑฐ๋ ์! ๐ก
๐ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ ๋ง ๊ธด ์ฌ์ ์ด์์ฃ ? ๐
์ฐ๋ฆฌ๋ iOS ์ฑ๋ฅ ์ต์ ํ์ ๊ธฐ์ด๋ถํฐ ๊ณ ๊ธ ๊ธฐ๋ฒ๊น์ง, Instruments ํ์ฉ๋ฒ๋ถํฐ ์ค์ ์ฌ๋ก๊น์ง ์ ๋ง ๋ง์ ๋ด์ฉ์ ๋ค๋ค์ด์. ์ด ๋ชจ๋ ๋ด์ฉ์ ํ ๋ฒ์ ๋ค ์ ์ฉํ๋ ค๊ณ ํ๋ฉด ๋ถ๋ด์ค๋ฌ์ธ ์ ์์ด์. ์ฒ์ฒํ, ํ๋์ฉ ์ ์ฉํด๋ณด์ธ์! ๐ข
๐ ํต์ฌ ์์ฝ
1. ์ธก์ ์ด ๋จผ์ ๋ค
์ถ์ธกํ์ง ๋ง๊ณ Instruments๋ก ์ธก์ ํ์ธ์. ๋ฐ์ดํฐ๊ฐ ์ง์ค์ ๋งํด์ค์.
2. ์ฌ์ฉ์ ๊ฒฝํ์ด ์ต์ฐ์
๊ธฐ์ ์ ์๋ฒฝํจ๋ณด๋ค ์ฌ์ฉ์๊ฐ ๋๋ผ๋ ์ฑ๋ฅ์ด ์ค์ํด์.
3. ๋ฉ์ธ ์ค๋ ๋๋ฅผ ์กด์คํ๋ผ
UI ์
๋ฐ์ดํธ๋ง ๋ฉ์ธ ์ค๋ ๋์์, ๋๋จธ์ง๋ ๋ฐฑ๊ทธ๋ผ์ด๋๋ก!
4. ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๊ปด ์ฐ์
๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ๋ฐฉ์งํ๊ณ , ์บ์๋ ์ ์ ํ ์ ํํ์ธ์.
5. ๋คํธ์ํฌ๋ฅผ ํจ์จ์ ์ผ๋ก
์์ฒญ์ ์ค์ด๊ณ , ์บ์ฑํ๊ณ , ๋ฐฐ์น๋ก ์ฒ๋ฆฌํ์ธ์.
6. ๋ฐฐํฐ๋ฆฌ๋ฅผ ์๊ฐํ์
์์น ์๋น์ค, ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ ์ต์ํํ์ธ์.
7. ์ง์์ ์ผ๋ก ๋ชจ๋ํฐ๋งํ๋ผ
ํ ๋ฒ ์ต์ ํํ๊ณ ๋์ด ์๋์์. ๊ณ์ ์ฒดํฌํ์ธ์!
๐ก ๋ค์ ๋จ๊ณ๋ก ๋์๊ฐ๊ธฐ
๋ ๋ฐฐ์ฐ๊ณ ์ถ๋ค๋ฉด:
โข Apple์ WWDC ์ธ์
์์ฒญํ๊ธฐ
โข "Advanced iOS App Architecture" ์ฑ
์ฝ๊ธฐ
โข ์คํ์์ค ํ๋ก์ ํธ ์ฝ๋ ๋ถ์ํ๊ธฐ
โข ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์ ์ฐธ์ฌํ๊ธฐ
์ค๋ ฅ์ ํค์ฐ๋ ค๋ฉด:
โข ์์ ํ๋ก์ ํธ๋ถํฐ ์ต์ ํ ์ฐ์ตํ๊ธฐ
โข ๋ค๋ฅธ ๊ฐ๋ฐ์์ ์ฝ๋ ๋ฆฌ๋ทฐํ๊ธฐ
โข ์ฑ๋ฅ ๋ฌธ์ ๋ฅผ ์ง์ ํด๊ฒฐํด๋ณด๊ธฐ
โข ๋ธ๋ก๊ทธ๋ ๋ฐํ๋ก ์ง์ ๊ณต์ ํ๊ธฐ
์ฑ๋ฅ ์ต์ ํ๋ ๋์ด ์๋ ์ฌ์ ์ด์์. ํญ์ ๋ ๋์ ๋ฐฉ๋ฒ์ด ์๊ณ , ์๋ก์ด ๊ธฐ์ ์ด ๋์ค๊ณ , ๋ฐฐ์ธ ๊ฒ ๋ง์ฃ . ํ์ง๋ง ๊ทธ๊ฒ ๋ฐ๋ก ๊ฐ๋ฐ์ ๋งค๋ ฅ ์๋๊น์? ๐
์ฌ๋ฌ๋ถ์ ์ฑ์ด ์ฌ์ฉ์๋ค์๊ฒ ์ต๊ณ ์ ๊ฒฝํ์ ์ ๊ณตํ๊ธธ ๋ฐ๋ผ์. ๊ทธ๋ฆฌ๊ณ ๊ธฐ์ตํ์ธ์, ์๋ฒฝํ ์ฑ์ ์์ด์. ํ์ง๋ง ๊ณ์ ๊ฐ์ ํ๋ ค๋ ๋
ธ๋ ฅ์ด ์๋ค๋ฉด, ๊ทธ๊ฒ๋ง์ผ๋ก๋ ์ถฉ๋ถํ ํ๋ฅญํ ๊ฐ๋ฐ์์์! ๐ช
๐ ๋ง์ง๋ง ์กฐ์ธ
์ฑ๋ฅ ์ต์ ํ๋ ๋ง๋ผํค์ด์ง ๋จ๊ฑฐ๋ฆฌ ๋ฌ๋ฆฌ๊ธฐ๊ฐ ์๋์์. ์กฐ๊ธํดํ์ง ๋ง๊ณ , ๊พธ์คํ ๊ฐ์ ํด๋๊ฐ์ธ์. ์์ ๊ฐ์ ๋ค์ด ๋ชจ์ฌ์ ํฐ ์ฐจ์ด๋ฅผ ๋ง๋ค์ด์.
๊ทธ๋ฆฌ๊ณ ํผ์ ๊ณ ๋ฏผํ์ง ๋ง์ธ์! ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ํตํ๊ณ , ๊ฒฝํ์ ๋๋๊ณ , ํจ๊ป ์ฑ์ฅํ์ธ์. ์ฐ๋ฆฌ๋ ๋ชจ๋ ๊ฐ์ ๊ธธ์ ๊ฑท๊ณ ์๋ ๋๋ฃ๋ค์ด๋๊น์! ๐ค
์ฌ๋ฌ๋ถ์ iOS ๊ฐ๋ฐ ์ฌ์ ์ ์์ํฉ๋๋ค! ํ์ดํ
! ๐โจ
์ด ๊ธ์ด ๋์์ด ๋์๋ค๋ฉด, ์ฌ๋ฌ๋ถ์ ํ๋ก์ ํธ์ ์ ์ฉํด๋ณด๊ณ ๊ฒฐ๊ณผ๋ฅผ ๊ณต์ ํด์ฃผ์ธ์. ์ฌ๋ฌ๋ถ์ ์ฑ๊ณต ์คํ ๋ฆฌ๋ฅผ ๋ฃ๊ณ ์ถ์ด์! ๐
Happy Coding! ๐ป๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.