Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper · leksjon

Grand Central Dispatch (GCD)

Implementer samtidige operasjoner med Grand Central Dispatch for å forbedre applikasjonens respons og ytelse.

Leksjon 2 av 411 trinn

Grand Central Dispatch (GCD) er en gratis leksjon i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.

Holde apper responsive

Har du noen gang brukt en app som frøs mens den lastet inn data? Det skyldes ofte at hovedtråden blokkeres.

Hovedtråden er stedet der alle oppdateringer av brukergrensesnittet og brukerinteraksjoner skjer. Hvis du utfører en langvarig oppgave der, blir appen uresponsiv.

Samtidighet betyr å kjøre flere oppgaver tilsynelatende samtidig. Dette holder hovedtråden ledig og sikrer en jevn brukeropplevelse.

Bli kjent med GCD

Grand Central Dispatch (GCD) er Apples kraftige API på lavt nivå for håndtering av samtidige operasjoner. Det er bygget oppå C og kodeblokker, og gjør det enkelt å utføre oppgaver asynkront.

GCD hjelper deg med å kjøre kode samtidig ved å administrere dispatch-køer. Du forteller GCD hvilke oppgaver som skal kjøres, og det avgjør når og hvordan de skal utføres på tilgjengelige prosessorkjerner.

Forstå dispatch-køer

GCD bruker dispatch-køer til å administrere oppgaver. Tenk på en kø som en rekke oppgaver som venter på å bli utført.

Serielle køer: Oppgavene kjøres én etter én, i den rekkefølgen de ble lagt til. Hver seriell kø behandler oppgavene sekvensielt.
Samtidige køer: Oppgavene startes i den rekkefølgen de ble lagt til, men kan kjøre samtidig. Rekkefølgen de fullføres i, er ikke garantert.

Brukergrensesnittets beste venn

Alle iOS-applikasjoner har en spesiell seriell kø som kalles hovedkøen for dispatch. Det er her alle oppdateringer av brukergrensesnittet må utføres.

Hvis du prøver å oppdatere brukergrensesnittet fra en bakgrunnstråd, kan appen krasje eller oppføre seg uventet. Bytt alltid tilbake til hovedkøen når du skal gjøre endringer i brukergrensesnittet.

Du får tilgang til den med dispatch_get_main_queue().

Systemets bakgrunnshjelpere

GCD tilbyr flere globale samtidige køer som du kan bruke til bakgrunnsoppgaver. Disse køene administreres av systemet og er optimalisert for ytelse.

De varierer etter klassen Quality of Service (QoS), som angir prioriteten til oppgavene:

.userInteractive: Brukergrensesnittrelatert, høyest prioritet.
.userInitiated: Oppgaver som brukeren har startet.
.utility: Langvarige oppgaver som ikke haster.
.background: Vedlikehold, lavest prioritet.

Gjør bakgrunnsarbeid enkelt

Den vanligste måten å bruke GCD på er med dispatch_async. Denne funksjonen legger en oppgave (en kodeblokk) til en kø og returnerer umiddelbart, slik at koden som kalte den, kan fortsette å kjøre.

Oppgaven kjøres deretter på en separat tråd i bakgrunnen. Dette passer perfekt for operasjoner som ikke trenger å blokkere hovedtråden, for eksempel nettverksforespørsler eller tunge beregninger.

#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;
}

Vente på en oppgave

Selv om dispatch_async er flott for ikke-blokkerende operasjoner, trenger du noen ganger å vente på at en oppgave skal fullføres før du fortsetter. Det er her dispatch_sync kommer inn.

dispatch_sync legger en oppgave til en kø og blokkerer deretter den gjeldende tråden til oppgaven er ferdig. Vær forsiktig: Kall aldri dispatch_sync på den gjeldende køen, siden det vil føre til en 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;
}

Sømløse oppdateringer av brukergrensesnittet

Et vanlig mønster i iOS-apper er å utføre en langvarig oppgave i bakgrunnen og deretter oppdatere brukergrensesnittet når den er ferdig. Dette hindrer brukergrensesnittet i å fryse.

Du oppnår dette ved å sende bakgrunnsoppgaven til en global, samtidig kø og deretter sende oppgaven som oppdaterer brukergrensesnittet, til hovedkøen.

#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;
}

Planlegge oppgaver til senere

Noen ganger må du planlegge at en oppgave skal kjøre etter en viss forsinkelse. GCD tilbyr dispatch_after til dette formålet.

Det er viktig å merke seg at dispatch_after ikke er en tidtaker i sanntid. Den legger ganske enkelt en kodeblokk til den angitte køen etter en minimumsforsinkelse. Det nøyaktige tidspunktet for kjøringen avhenger av aktiviteten i køen.

#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-sjekk

La oss teste hvor godt du har forstått GCD.

Besvar den i den interaktive leksjonen

Oppsummering av GCD

Flott jobbet! Du har lært det grunnleggende om Grand Central Dispatch.

GCD bidrar til å håndtere samtidige oppgaver slik at appen forblir responsiv.
Dispatch-køer (serielle og samtidige) styrer kjøringen av oppgaver.
Hovedkøen brukes til oppdateringer av brukergrensesnittet og åpnes alltid via dispatch_async.
Globale samtidige køer brukes til arbeid i bakgrunnen.
dispatch_async kjører oppgaver uten å blokkere, mens dispatch_sync venter på oppgavene.

Å mestre GCD er avgjørende for å bygge iOS-applikasjoner med høy ytelse og god respons.

Gratis å komme i gang

Lær deg Objective-C med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Grand Central Dispatch (GCD)» gratis?

Ja – hele teksten i «Grand Central Dispatch (GCD)» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.

Hva lærer jeg i «Grand Central Dispatch (GCD)»?

Implementer samtidige operasjoner med Grand Central Dispatch for å forbedre applikasjonens respons og ytelse. Du øver på Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper?

Ingen tidligere erfaring er nødvendig. Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Grand Central Dispatch (GCD)»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjonen?

Ja. Alle Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper