Grand Central Dispatch(GCD)
Grand Central Dispatch를 사용해 동시 작업을 구현하고 애플리케이션의 응답성과 성능을 향상합니다.
Grand Central Dispatch(GCD)은(는) CoddyKit의 무료 Objective-C iOS Development for Legacy & Enterprise Apps 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Objective-C iOS Development for Legacy & Enterprise Apps 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Objective-C iOS Development for Legacy & Enterprise Apps 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
Keeping Apps Responsive
Ever used an app that froze when loading data? That's often due to blocking the main thread.
The main thread is where all UI updates and user interactions happen. If you perform a long-running task there, your app becomes unresponsive.
Concurrency means running multiple tasks seemingly at the same time. This keeps the main thread free, ensuring a smooth user experience.
Meet GCD
Grand Central Dispatch (GCD) is Apple's powerful low-level API for managing concurrent operations. It's built on top of C and blocks, and makes it easy to perform tasks asynchronously.
GCD helps you run code concurrently by managing dispatch queues. You tell GCD what tasks to run, and it decides when and how to execute them on available processor cores.
Understanding Dispatch Queues
GCD uses dispatch queues to manage tasks. Think of a queue as a line of tasks waiting to be executed.
- Serial Queues: Tasks run one by one, in the order they were added. Each serial queue processes its tasks sequentially.
- Concurrent Queues: Tasks are started in the order they are added, but can run at the same time (concurrently). The order of completion is not guaranteed.
The UI's Best Friend
Every iOS application has a special serial queue called the main dispatch queue. This is where all UI updates must happen.
If you try to update the UI from a background thread, your app might crash or behave unexpectedly. Always switch back to the main queue for UI changes.
You access it using dispatch_get_main_queue().
System's Background Helpers
GCD provides several global concurrent queues that you can use for background tasks. These queues are managed by the system and optimized for performance.
They differ by their Quality of Service (QoS) class, which indicates the priority of tasks:
.userInteractive: UI-related, highest priority..userInitiated: User-requested tasks..utility: Long-running, non-urgent tasks..background: Maintenance, lowest priority.
Background Work Made Easy
The most common way to use GCD is with dispatch_async. This function adds a task (a block of code) to a queue and immediately returns, allowing the calling code to continue execution.
The task will then run on a separate thread in the background. This is perfect for operations that don't need to block the main thread, like network requests or heavy computations.
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"1. Program starts.");
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"3. Doing some background work...");
[NSThread sleepForTimeInterval:1.0]; // Simulate work
NSLog(@"4. Background work finished.");
});
NSLog(@"2. Program continues immediately after dispatch_async.");
[NSThread sleepForTimeInterval:2.0]; // Keep main thread alive
}
return 0;
}Waiting for a Task
While dispatch_async is great for non-blocking operations, sometimes you need to wait for a task to complete before continuing. That's where dispatch_sync comes in.
dispatch_sync adds a task to a queue and then blocks the current thread until that task finishes execution. Be careful: never call dispatch_sync on the current queue, as it will cause a deadlock!
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"1. Program starts.");
dispatch_queue_t mySerialQueue = dispatch_queue_create("com.coddykit.myserialqueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(mySerialQueue, ^{
NSLog(@"2. This synchronous task runs now.");
[NSThread sleepForTimeInterval:0.5];
});
NSLog(@"3. Program continues AFTER the synchronous task completes.");
}
return 0;
}Seamless UI Updates
A common pattern in iOS apps is to perform a long-running task in the background and then update the UI once it's done. This prevents the UI from freezing.
You achieve this by dispatching the background task to a global concurrent queue, and then dispatching the UI update task to the main queue.
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"1. App starts, fetching data...");
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"2. Performing heavy data fetch on background thread...");
[NSThread sleepForTimeInterval:1.5]; // Simulate network call or heavy computation
NSString *fetchedData = @"User Data Loaded!";
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"3. Data fetched! Updating UI on main thread: %@", fetchedData);
// In a real app, you'd update a UILabel or UIImageView here.
});
});
NSLog(@"4. App remains responsive while data fetches.");
[NSThread sleepForTimeInterval:2.0]; // Keep main thread alive
}
return 0;
}Scheduling Tasks Later
Sometimes you need to schedule a task to run after a certain delay. GCD provides dispatch_after for this purpose.
It's important to note that dispatch_after is not a real-time timer. It simply adds a block to the specified queue after a minimum delay. The exact execution time depends on the queue's activity.
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"1. Program starts.");
NSTimeInterval delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^{
NSLog(@"2. This message appears after 2 seconds.");
});
NSLog(@"3. Program continues immediately, waiting for delayed task.");
[NSThread sleepForTimeInterval:3.0]; // Keep main thread alive
}
return 0;
}GCD Check-up
Let's test your understanding of GCD.
GCD Summary
Great job! You've learned the fundamentals of Grand Central Dispatch.
- GCD helps manage concurrent tasks to keep your app responsive.
- Dispatch queues (serial and concurrent) control task execution.
- The main queue is for UI updates, always accessed via
dispatch_async. - Global concurrent queues are for background work.
dispatch_asyncruns tasks without blocking,dispatch_syncwaits for tasks.
Mastering GCD is crucial for building high-performance, responsive iOS applications.
자주 묻는 질문
“Grand Central Dispatch(GCD)” 강의는 무료인가요?
네 — “Grand Central Dispatch(GCD)” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Objective-C iOS Development for Legacy & Enterprise Apps 강의 전체를 잠금 해제할 수 있습니다. Objective-C iOS Development for Legacy & Enterprise Apps 강의에는 총 4개의 강의가 포함되어 있습니다.
“Grand Central Dispatch(GCD)”에서 뭘 배우나요?
Grand Central Dispatch를 사용해 동시 작업을 구현하고 애플리케이션의 응답성과 성능을 향상합니다. 브라우저에서 직접 실행하는 실습 코드로 Objective-C iOS Development for Legacy & Enterprise Apps을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Objective-C iOS Development for Legacy & Enterprise Apps을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Objective-C iOS Development for Legacy & Enterprise Apps은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.
“Grand Central Dispatch(GCD)” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Objective-C iOS Development for Legacy & Enterprise Apps 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Objective-C iOS Development for Legacy & Enterprise Apps 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.
이 강의의 모든 강의
- API 호출을 위한 NSURLSession
- Grand Central Dispatch(GCD)
- 복잡한 작업을 위한 NSOperationQueue
- NSJSONSerialization으로 JSON 파싱하기