Objective-C iOS Development for Legacy & Enterprise Apps · Ders

Grand Central Dispatch (GCD)

Uygulama duyarlılığını ve performansını artırmak için Grand Central Dispatch kullanarak eşzamanlı işlemler uygulayın.

Grand Central Dispatch (GCD), CoddyKit'te ücretsiz bir Objective-C iOS Development for Legacy & Enterprise Apps dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Objective-C iOS Development for Legacy & Enterprise Apps öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Objective-C iOS Development for Legacy & Enterprise Apps kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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_async runs tasks without blocking, dispatch_sync waits for tasks.

Mastering GCD is crucial for building high-performance, responsive iOS applications.

Sıkça Sorulan Sorular

“Grand Central Dispatch (GCD)” dersi ücretsiz mi?

Evet — “Grand Central Dispatch (GCD)” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Objective-C iOS Development for Legacy & Enterprise Apps kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Objective-C iOS Development for Legacy & Enterprise Apps kursu toplamda 4 dersten oluşur.

“Grand Central Dispatch (GCD)” dersinde ne öğreneceğim?

Uygulama duyarlılığını ve performansını artırmak için Grand Central Dispatch kullanarak eşzamanlı işlemler uygulayın. Objective-C iOS Development for Legacy & Enterprise Apps ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Objective-C iOS Development for Legacy & Enterprise Apps öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Objective-C iOS Development for Legacy & Enterprise Apps, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Grand Central Dispatch (GCD)” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Objective-C iOS Development for Legacy & Enterprise Apps dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Objective-C iOS Development for Legacy & Enterprise Apps dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Objective-C iOS Development for Legacy & Enterprise Apps Sayfasına Dön