Použití Simple DirectMedia Layer API

Vlákna

Vytvoření jednoduchého vlákna

Vlákno se vytvoří, když se funkci SDL_CreateThread() předá ukazatel na jinou funkci. Pokud SDL_CreateThread() skončí úspěšně, vaše funkce poběží souběžně se zbytkem aplikace ve svém vlastním kontextu (zásobník, registry atd.), ale je současně schopná přistupovat k paměti a otevřeným souborům používaným zbytkem aplikace.

Tip:
S druhým argumentem předaným funkci SDL_CreateThread() se nakládá jako s parametrem volané funkce vznikajícího vlákna. Můžete ho využít k předání hodnot v zásobníku, nebo jenom jako ukazatel na data určená pro nové vlákno.

Example:

#include "SDL_thread.h"

int global_data = 0;

int thread_func(void *unused)
{
    int last_value = 0;

    while ( global_data != -1 ) {
        if ( global_data != last_value ) {
            printf("Data se změnila na %d\n", global_data);
            last_value = global_data;
        }
        SDL_Delay(100);
    }
    printf("Ukončuji vlákno\n");
    return(0);
}

{
    SDL_Thread *thread;
    int i;

    thread = SDL_CreateThread(thread_func, NULL);
    if ( thread == NULL ) {
        fprintf(stderr, "Není možné vytvořit vlákno: %s\n", SDL_GetError());
        return;
    }

    for ( i=0; i<5; ++i ) {
        printf("Změna hodnoty na %d\n", i);
        global_data = i;
        SDL_Delay(1000);
    }

    printf("Signál vláknu k ukončení\n");
    global_data = -1;
    SDL_WaitThread(thread, NULL);
}

Sladění přístupu ke zdroji

Můžete zabránit situaci, kdy více než jedno vlákno přistupuje ke zdroji vytvořením tzv. mutexu a uzavřením přístupu k tomuto zdroji pomocí volání uzamknutí (SDL_mutexP()) a odemknutí (SDL_mutexV()).

Tip:
Každá data, ke kterým může přistupovat více než jedno vlákno, by měla být chráněna pomocí mutexu.

Příklad:

#include "SDL_thread.h"
#include "SDL_mutex.h"

int potty = 0;
int gotta_go;

int thread_func(void *data)
{
    SDL_mutex *lock = (SDL_mutex *)data;
    int times_went;

    times_went = 0;
    while ( gotta_go ) {
        SDL_mutexP(lock);    /* Zamknout potty */
        ++potty;
        printf("Vlákno %d používá potty\n", SDL_ThreadID());
        if ( potty > 1 ) {
            printf("Uh oh, někdo další používá potty!\n");
        }
        --potty;
        SDL_mutexV(lock);
        ++times_went;
    }
    printf("Ano\n");
    return(times_went);
}

{
    const int progeny = 5;
    SDL_Thread *kids[progeny];
    SDL_mutex  *lock;
    int i, lots;

    /* Vytvořit synchronizační zámek */
    lock = SDL_CreateMutex();

    gotta_go = 1;
    for ( i=0; i<progeny; ++i ) {
        kids[i] = SDL_CreateThread(thread_func, lock);
    }

    SDL_Delay(5*1000);
    SDL_mutexP(lock);
    printf("Všichni hotovi?\n");
    gotta_go = 0;
    SDL_mutexV(lock);

    for ( i=0; i<progeny; ++i ) {
        SDL_WaitThread(kids[i], &lots);
        printf("Vlákno %d použilo potty %d krát\n", i+1, lots);
    }
    SDL_DestroyMutex(lock);
}

[Předchozí] Obsah [Další]