Be Book Kernel Kit Kernel Kit Indeks

Wątki i zespoły

Zadeklarowany w:  be/kernel/OS.h headers/be/kernel/OS.h
Biblioteka: libroot.so
Streszczenie:  więcej...

 

Wątek jest synchronicznym procesem (przebiegiem), który wykonuje serię instrukcji programu. Kiedy odpalasz jakąś aplikację, początkowy wątek - główny wątek - jest tworzony automatycznie (lub zapoczątkowany) i wyznaczony do działania. Od głównego wątku możesz zapoczątkowywać i uruchamiać dodatkowe wątki; od każdego z tych wątków możesz zapoczątkować i uruchamiać dalsze wątki i tak dalej. Zbiór wątków, które są rozpoczęte od głównego wątku - inaczej mówiąc, wątki, które obejmują aplikację - są nazywane zespołem. Wszystkie wątki we wszystkich zespołach działają jednocześnie i asynchronicznie ze sobą wzajemnie.

Aby uzyskać więcej informacji o wątkach i zespołach, patrz do "Pojęcia wątku i zespołu".


Funkcje Wątków i Zespołów


estimate_max_scheduling_latency()

Zadeklarowana w:  be/kernel/scheduler.h

bigtime_t estimate_max_scheduling_latency(thread_id thread = -1)

Zwraca opóźnienie szeregowania dla określonego wątku podane w mikrosekundach. Określenie argumentu thread_id równego -1 zwraca opóźnienie szeregowania dla wątku bieżącego (czyli aktualnie wykonującego się na procesorze - przyp. tłum.).


exit_thread(), kill_thread(), kill_team(), on_exit_thread()

void exit_thread(status_t return_value)
status_t kill_thread(thread_id thread)
status_t kill_team(team_id team)
status_t on_exit_thread(void (*callback)(void *), void *data)

Te funkcje nakazują jednemu lub więcej wątkom, żeby zatrzymały swoje wykonanie:

Zakończenie działania wątku jest całkowicie bezpieczną rzeczą do wykonania - ponieważ wątek może zakończyć jedynie swoje działanie, jest przyjęte, że wątek wie co robi. Zabijanie jakiegoś innego wątku lub całego zespołu jest nieco drastyczne ponieważ świadectwo(a) śmierci będzie dostarczone w nieokreślonym czasie. Ponadto, zabijanie wątku może spowodować wyciek pamięci, zasoby (pamięć, urządzenia, pliki itd.) które zostały przydzielone przez wątek nie mogą zostać zwolnione. Zabijanie z drugiej strony całego zespołu nie spowoduje wycieku ponieważ system odzyskuje wszystkie zasoby gdy ginie zespół.

Miej na uwadze to, że wątki giną automatycznie (a ich zasoby są odzyskiwane) jeżeli zezwala się im na naturalnie zakończenie działania. Wtedy jedynie musisz zabić wątek, jeśli coś poszło nie tak jak trzeba.

ZWRACANE KODY


find_thread()

thread_id find_thread(const char *name)

Znajduje i zwraca wątek o podanej nazwie. Argument name równy NULL zwraca wątek wywołujący.

Nazwa wątku jest przypisywana gdy wątek jest rozpoczynany. Nazwa może być zmieniona poźniej poprzez funkcję rename_thread(). Oznacza to, że nazwy wątkó nie muszą być unikalne: jeśli dwa (lub więcej) wątkó rozgłasza ta samą nazwę, wywołanie funkcji find_thread() na tej nazwie zwróci pierwszy tak nazwany wątek, który znajdzie. Nie ma żadnego sposobu, aby dokonywać przeglądania identycznie ponazywanych wątków.

ZWRACANE KODY


get_team_info(), get_next_team_info()

status_t get_team_info(team_id team, team_info *info)
status_t get_next_team_info(int32 *cookie, team_info *info)

Funkcje kopiują do argumentu info strukturę team_info dla określonego zespołu. Funkcja get_team_info() uzyskuje informacje o zespole identyfikowanym przez argument team. Aby uzyskać informację o jądrze, użyj B_SYSTEM_TEAM jako argumentu team.

Wersja get_next_team_info() pozwala Ci krok po kroku wyszczególnić wszystkie zespoły. Argument cookie jest znacznikiem miejsca; ustaw go na 0 w Twoim pierwszym wywołaniu i pozwól funkcji wykonać resztę. Funkcja zwraca wartości B_BAD_VALUE gdy nie ma więcej żadnych obszarów do odwiedzenia:

/* Uzyskaj team_info dla każdego zespołu. */
team_info info;
int32 cookie = 0;

while (get_next_team_info(0, &cookie, &info) == B_OK)
   ...

Popatrz do team_info aby przeglądnąć opis tej struktury.

ZWRACANE KODY


get_thread_info(), get_next_thread_info()

status_t get_thread_info(thread_id thread, thread_info *info)
status_t get_next_thread_info(team_id team,
      int32 *cookie,
      thread_info *info)

Te funkcje kopiują do argumentu info strukturę thread_info dla określonego wątku:

Funkcja get_thread_info() podaje informację o wątku identyfikowanym przez argument thread.

Funkcja get_next_thread_info() pozwala Ci krok po kroku wyszczególnić wszystkie wątki zespołu poprzez iterowane wywołania. Argument team identyfikuje zespół który chcesz przeglądać; wartość team równa 0 oznacza zespół wywołującego wątku. Argument cookie jest znacznikiem miejsca; ustaw go na 0 w Twoim pierwszym wywołaniu i pozwól funkcji wykonać resztę. Funkcja zwraca wartości B_BAD_VALUE gdy nie ma więcej żadnych wątków do odwiedzenia:

/* Uzyskaj thread_info dla każdego wątku w tym zespole. */
thread_info info;
int32 cookie = 0;

while (get_next_thread_info(0, &cookie, &info) == B_OK)
   ...

Wartość pola priority (priorytet) opisuje "pośpiech" wątku; wyższa wartość, bardziej pilny wątek. Bardziej pilny watek uzyskuje większe zainteresowanie ze strony procesora. Oczekiwane wartości priorytetu znajdują się między 0 a 120. Popatrz do "Priorytety wątku " aby sobie uzupełnić tą historię.

Informacja o wątku jest dostarczona głównie jako pomoc do debugowania (przy usuwaniu błędów w programie). Żadna z wartości, które znajdujesz w strukturze thread_info nie gwarantuje, że będzie aktualna - stan wątku, dla przykładu, prawie na pewno zmieni się w czasie powrotu z funkcji get_thread_info().

ZWRACANE KODY


has_data()  see send_data()


rename_thread()

status_t rename_thread(thread_id thread, const char *name)

Zmienia nazwę podanego wątku na tą w argumencie name. Nazwa nie może być dłuższa niż B_OS_NAME_LENGTH (32 znaki).

ZWRACANE KODY

resume_thread()

status_t resume_thread(thread_id thread)

Mówi nowemu lub uśpionemu wątkowi aby rozpoczął wykonywanie instrukcji. Jeśli wątek dopiero co został rozpoczęty, zgłaszać się i wykonuje funkcję wątku zadeklarowaną w spawn_thread(). Jeśli wątek był poprzednio uśpiony (poprzez suspend_thread()), kontynuuje on od tego miejsca gdzie został uśpiony.

Nie możesz użyć tej funkcji do obudzenia uśpionego wątku lub odblokowania wątku wątku oczekującego na uzyskanie semafora lub czekającego na wywołanie receive_data(). Jednak, możesz odblokować dowolne z tych wątków przez uśpienie a następnie przywrócenie. Zablokowane wątki, które są przywrócone zwracają wartość B_INTERRUPTED.

resume_thread() jest tym samym co wysłanie sygnału SIGCONT do wątku.

ZWRACANE KODY


receive_data()

Uzyskuje komunikat z podręcznej pamięci komunikatów wątku. Komunikat będzie tam umieszczony przez poprzednie wywołanie funkcji send_data(). Jeżeli pamięć podręczna jest pusta, funkcja receive_data() jest blokowana, aż pokaże się jeden komunikat - ta funkcja nigdy nie kończy działania bez zwrócenia jakiejś wartości.

thread_id wątku, który wywołał send_data() jest zwracany przez referencję w argumencie sender. Zauważ, że nie ma żadnej gwarancji, że nadawca jeszcze będzie żywy w czasie gdy dostajesz jego ID. Również, wartość sender przychodząca w funkcji jest ignorowana - nie możesz poprosić o komunikat od konkretnego nadawcy.

Funkcja send_data() kopiuje dwie części danych do pamięci podręcznej komunikatu wątku:

Niestety, nie ma sposobu by powiedzieć, ile danych jest w pamięci podręcznej przed wywołaniem receive_data():

Każde wywoanie receive_data() odpowiada dokładnie jednemu wywołaniu send_data(). Nie posiadając poprzedniego wywołania jego kolegi, receive_data() będzie blokować aż do wywołania send_data(). Jeżeli nie chcesz blokować, powinieneś wywołać has_data() przed wywołaniem receive_data() (i przystąpić do wywołania receive_data() tylko jeżeli funkcja has_data() zwróci wartość true).

ZWRACANE KODY


send_data(), receive_data(), has_data()

status_t send_data(thread_id thread,
      int32 code,
      void *buffer,
      size_t buffer_size)
int32 receive_data(thread_id *sender,
      void *buffer,
      size_t buffer_size)
bool has_data(thread_id thread)

Każdy wątek ma przypisaną pamięć podręczną przeznaczoną na komunikat o pojemności jednego komunikatu. Te funkcje udostępniają tą pamięć podręczną.

send_data() kopiuje komunikat do pamięci podręcznej wątku przekazywanego jako argument thread. Wątek docelowy odbiera komunikat (i opróżnia pamięć podręczną) przez wywołanie funkcji receive_data().

Są dwie części w komunikacie:

Dodatkowo do zwracanego boezpośrednio kodu code i kopiowania danych komunikatu do jego argumentu buffer, funkcja receive_data() ustawia identyfikator wątku, który wysłał komunikat jako nadawcę w argumencie sender.

send_data() blokuje się jezeli jest nieprzeczytany komunikat w pamięci podręcznej docelowego wątku; w przeciwnym wypadku natychmiast zwraca ona wartość (t.j. nie czeka ona aż docelowy wątek wywoła funkcję receive_data()). Analogicznie, receive_data() blokuje się dopóki ma ona komunikat do odebrania.

W poniższym przykładzie, główny wątek zapoczątkowuje wątek, wysyła mu komunikat a potem powiadamia go aby zaczął on działać (czyli uruchamia go - przyp. tłum.):

main()
{
   thread_id other_thread;
   int32 code = 63;
   char *buf = "Hello";

   other_thread = spawn_thread(thread_func, ...);
   send_data(other_thread, code, (void *)buf, strlen(buf));
   resume_thread(other_thread);
   ...
}

Do odebrania komunikatu, wątek docelowy wywołuje funkcję receive_data():

int32 thread_func(void *data)
{
   thread_id sender;
   int32 code;
   char buf[512];

   code = receive_data(&sender, (void *)buf, sizeof(buf));
   ...
}

Pamiętaj, że dane komunikatu są skopiowane do bufora; musisz przydzielić odpowiednią pamięć dla danych. Jeśli bufor nie jest wystarczająco duży by pomieścić wszystkie dane komunikatu, pozostałą porcja jest odrzucana. Zauważ, jednakże, że nie ma żadnego sposobu dla wątku, aby określić jak dużo danych zostało skopiowane do jego pamięci podręcznej.

has_data() zwraca true jeśli wątek thread ma komunikat w pamięci podręcznej. Pozornie, używasz tej funkcji przed wołaniem send_data() lub receive_data() aby uniknąć blokowania:

if (!has_data(target_thread))
   err = send_data(target_thread, ...);

/* or */

if (has_data(find_thread(NULL))
   code = receive_data(...);

To działa dla funkcji receive_data() ale zauważ, że występuje tutaj stan wyścigu pomiędzy wywołaniami has_data() i send_data(). Tymczasem inny wątek mógł wysłać komunikat do adresata.

ZWRACANE KODY

send_data() zwraca:


set_thread_priority() , suggest_thread_priority()

status_t set_thread_priority(thread_id thread, int32 new_priority)

Zadeklarowany w:  be/kernel/scheduler.h

int32 suggest_thread_priority(uint32 what = B_DEFAULT_MEDIA_PRIORITY,
      int32 period = 0,
      bigtime_t jitter = 0,
      bigtime_t length = 0)

set_thread_priority() ustawia ponownie priorytet danego wątku na wartość równą new_priority. Oczekiawana wartość priorytetu zawiera się pomiędzy 0 a 120. Popatrz do opisu schematu priorytetu "Priorytety wątku" i listy predefiniowanych stałych priorytetu "Thread Priority Values".

suggest_thread_priority() pobiera informację o wątku i zwraca sugerowany priorytet, który Ty możesz przekazać do funkcji set_thread_priority() (lub bardziej odpowiednie, do funkcji spawn_thread()).

Wartość what jest maską, która wskazuje typ działalności do której wątek będzie użyty. Dostępne wartości są wypisane w Sugerowane Priortety Wątku.

Okres period jest liczbą określającą ile razy w ciągu sekundy wątek potrzebuje działać (określ 0 jeśli wątek potrzebuje działać bez przerwy). Rozrzut jitter jest oszacowaniem w mikrosekundach, jak wiele okres może się różnić, pod warunkiem, że jest zawieszany period razy na skeundę.

length jest przybliżoną ilością czasu, w mikrosekundach, przez jaką wątek będzie działał po wzewaniu (t.j., ilość czasu, która będzie upływać pomiedzy chwilą gdy odbierze on komunikat, poprzez przetworzenie go aż do jego ponownego oczekiwania na kolejny komunikat).

Przykładowo, jeśli zapoczątkowałeś wątek do obsługi odświeżania wideo dla gry komputerowej i chcesz wyświetlać uaktualnienie 30 razy na sekundę, możesz użyć kodu podobnego do poniższego:

int32 priority;
priority = suggest_thread_priority(B_LIVE_3D_RENDERING, 30, 1000, 150);
th = spawn_thread(func, "render_thread", priority, NULL)

Zapoczątkowuje on wątek z priorytetem odpowiednim dla wątku renderującego 3D na żywo (na bieżąco), który chce być uruchamiany 30 razy na skeundę z odchyłką tylko 1000 mikrosekund. Oszacowano, że każde wywołanie kodu wątku zajmie 150 mikrosekund. Oczywiście wartości jitter i length powinny być dostrojone do konkretnej aplikacji.

ZWRACANE KODY

set_thread_priority() zwraca...

Dodatniew wartości całkowite. Jeśli funkcja zakończyłą się sukcesem, zwracany jest poprzedni priorytet.

snooze() , snooze_until()

status_t snooze(bigtime_t microseconds)
status_t snooze_until(bigtime_t microseconds, int timebase)

snooze() blokuje wywołanie wątku na daną liczbę mikrosekund.

snooze_until() blokuje się aż osiągnie czas odmierzony w danej podstawie czasu. Dozwoloną obecnie wartością podstawy czasu jest tylko B_SYSTEM_TIMEBASE, który mierzy czas w stosunku do zegara systemowego (jaki jest zgłaszany przez system_time()).

ZWRACANE KODY


snooze_until() patrz snooze()


spawn_thread()

thread_id spawn_thread(thread_func func,
      const char *name,
      int32 priority,
      void *data)

Tworzy nowy wątek i zwraca jego identyfikator thread_id (liczba całkowita dodatnia). Argumentami są:

Nowo zapoczątkowany wątek jest w stanie uśpienia (B_THREAD_SUSPENDED). Aby wątkowi powiedzieć żeby zaczął działać, przekaż jego identyfikator thread_id do funkcji resume_thread(). Wątek będzie kontynuował działąnie aż do wyjścia wyjdzie z funkcji wątku lub dopóki wątek nie zostanie jawnie unicestwiony (poprzez sygnał lub wywołanie funkcji exit_thread(), kill_thread() lub kill_team()).

ZWRACANE KODY


suggest_thread_priority() patrz set_thread_priority()


suspend_thread()

status_t suspend_thread(thread_id thread)

Wstrzywuje wykonanie danego wątku ale nie unicestwia wątku całkowicie. Wątek pozostaje w stanie zawieszenia (funkcja suspend_thread() blokuje się) dopóki nie zostanie powiadomiony aby zaczął działać poprzez wywołanie funkcji resume_thread() . Nic Cię nie powstrzymuje od zawieszania twojego własnego wątku, t.j.:

suspend_thread(find_thread(NULL));

Oczywiście, jest to sprytne tylko jeśli masz jakiś inny wątek, który będzie przywrócony później.

Mozesz uśpić jakiś wątek, bez względu na jego aktualny stan. Ale bądź ostrożny: jeśli wątek jest zablokowany na semaforze (przykładowo), dalsze wywołanie funkcji resume_thread() będzie przeskakiwać poza przejęciem semafora.

Uśpienia nie sa zagnieżdżane. Pojedyncze wywołanie resume_thread() przywraca wątek z uśpienia bez względu na liczbę wywołań suspend_thread() przez nie go odebranych.

suspend_thread() jest tym samym jak wysłanie sygnału SIGSTOP do wątku.

ZWRACANE KODY


wait_for_thread()

status_t wait_for_thread(thread_id thread, status_t *exit_value)

Ta funkcja powoduje przekazanie wątkowi informacji aby czekał aż wątek thread ("wątek docelowy") zostanie unicestwiony. Jeśli wątek thread jest uśpiony (lub swieżo zapoczątkowany), funkcja wait_for_thread() będzie go wznawiać do działania.

Kiedy wątek docelowy jest unicestwiony, wartość która była zwrócona przez funkcję wątku (lub narzucona przez exit_thread()) jest zwracana w argumencie exit_value. Jeśli wątek docelowy był unicestwiony (przez kill_thread() lub kill_team()) lub jeśli funkcja wątku nie zwróciła wartości, wartość argumentu exit_value będzie niepewna.

Musisz podać poprawny wskaźnik jako drugi argument do funkcji wait_for_thread(). Nie możesz przekazywać NULL nawet wtedy, jeśli nie jesteś zainteresowany zwracaną wartością.

ZWRACANE KODY


Typy i Struktury Wątku i Zespołu


team_id, thread_id

typedef int32 team_id ;

typedef int32 thread_id ;

Te liczbny identyfikatorów identyfikują unikalnie odpowiednio zespoły i wątki.


team_info

typedef struct {
      team_id team;
      int32 thread_count;
      int32 image_count;
      int32 area_count;
      thread_id debugger_nub_thread;
      port_id debugger_nub_port;
      int32 argc;
      char args[64];
      uid_t uid;
      gid_t gid;
      } team_info;

Struktura team_info zwraca informację o zespole. Do uzyskania tych struktur użyj funkcji get_team_info() lub get_next_team_info().

Pierwsze pole jest oczywiste; następne trzy są znośne: podają one liczbę wątków, które mają być zapoczątkowane, obrazy które mają być załadowane i obszary które zostały utworzone lub sklonowane wtym zespole.

Pola debugger'a są używane przez ten, uhm, ten...debugger?

Pole argc jest liczbą argumentów wiersza poleceń, które będą użyte do uruchomienia zespołu; args jest kopia pierwszych 64 znaków wywołania z wiersza poleceń. Jeśli zespół jest aplikacją uruchomioną poprzez interfejs użytkownika (przez dwukrotnre kliknięcie lub przez zaakceptowanie upuszczonej ikony), wtedy argc jest 1 a args jest nazwą pliku wykonywalnego aplikacji.

uid i gid identyfikują użytkownika i grupę która jest "właścicielem" zespołu. Możesz użyć tych wartości, by zagrać gry pozwoleń.


thread_func

typedef int32 (*thread_func)(void *data);

thread_func jest prototypem dla funkcji wątku thread function. Określasz funkcję wątku przez przekazanie funkcji thread_func jako pierwszego argumentu do funkcji spawn_thread(); ostatni argument przekazwyany do funkcji spawn_thread() jest wysyłany jako argument data funkcji wątku. Kiedy funkcja wątku się zakończy, zapoczatkowany wątek jest automatycznie unicestwiany. Aby uzyskać zwracaną wartość funkcji thread_func, inne wątki muszą czekać na wywołanie funkcji wait_for_thread().

Zauważ, że spawn_thread() nie koiuje danych na które wskazuje argument data. Ona po prostu dosłownie przekazuje wskaźnik. Nigdy nie przekazuj wskaźnik, który jest przydzielany lokalnie (na stosie).


thread_info

typedef struct {
      thread_id thread;
      team_id team;
      char name[B_OS_NAME_LENGTH];
      thread_state state;
      sem_id sem;
      int32 priority;
      bigtime_t user_time;
      bigtime_t kernel_time;
      void *stack_base;
      void *stack_end;
      } thread_info

The thread_info structure contains information about a thread. To retrieve one of these structure, use get_thread_info() or get_next_thread_info().

The thread, team, and name fields contain the indicated information.

state opisuje to co wątek aktualnie robi (patrz do thread_state aby zobaczyć listę stanów). Jeśli wątek czeka na przejęcie semafora, sem jest tym semaforem.

priority jest wartością która wskazuje poziom uwagi uzyskiwany przez wątek (patrz do "Priorytet wątku").

user_time i kernel_time są ilością czasu, w mikrosekundach, które wątek spędził wykonując kod użytkownika i odpowiednio ilość czasu działającego na rzecz wątku.

stack_base i stack_end są wskaźnikami do pierwszego bajtu i ostatniego bajtu w stosie wykonania wątku. Obecnie rozmiar stosu jest ustalony na około 256k.

Te dwa wskaźniki są obecnie odwrócone tak, że stack_base jest mniejszy niż stack_end. (W świecie stosu rosnącego w dół, adres bazowy powinien być większy niż końcowy.)


Stałe Wątku i Zespołu


B_SYSTEM_TEAM

#define B_SYSTEM_TEAM ...

Użyj tej stałej jako pierwszego argumentu dla funkcji get_team_info() aby uzyskać infomację zespołową o jądrze).


B_SYSTEM_TIMEBASE

,
#define B_SYSTEM_TIMEBASE ...

Stała podstawy czasu systemu jest używana jako podstawa do mierzenia czasu w funkcji snooze_until(). (Obecnie jest dostępna tylko ta podstawa czasu.)


be_task_flags

Zadeklarowany w:  be/kernel/scheduler.h

enum be_task_flags { B_DEFAULT_MEDIA_PRIORITY,
      B_OFFLINE_PROCESSING
       B_STATUS_RENDERING,
      B_USER_INPUT_HANDLING
      
B_LIVE_VIDEO_MANIPULATION
      };

Stała Znaczenie
B_DEFAULT_MEDIA_PRIORITY Wątek nie wykonuje niczego wyspecjalizowanego.
B_OFFLINE_PROCESSING Wątek wykonuje obliczenia, które nie są obliczeniami czasu rzeczywistego.
B_STATUS_RENDERING Wątek jest w stanie renderowania lub wyświetlania podglądu.
B_USER_INPUT_HANDLING Wątek obsługuje wejście użytkownika.
B_LIVE_VIDEO_MANIPULATION Wątek przetwarza wideo na żywo (live) (filtrowanie, kompresja, dekompresja, itd.).
B_VIDEO_PLAYBACK Wątek odtwarza wideo z urządzenia sprzętowego.
B_VIDEO_RECORDING Wątek zapisuje wideo z urządzenia sprzętowego.
B_LIVE_AUDIO_MANIPULATION Wątek wykonuje manipulację danymi audio na żywo w czasie rzeczywistym (filtrowanie, kompresja, dekompresja, itd.).
B_AUDIO_PLAYBACK Wątek odtwarza dźwięk z urządzenia sprzętowego.
B_AUDIO_RECORDING Wątek zapisuje dźwięk z urządzenia sprzętowego.
B_LIVE_3D_RENDERING Wątek wykonuje renderowanie 3D na żywo.
B_NUMBER_CRUNCHING Wątek wykonuje przetwarzanie danych.

Te stałe opisują do jakich działań jest przeznaczony wątek. Musisz użyć tych stałych gdy pytasz o sugerowany priorytet (patrz do suggest_thread_priority()).

Te stałe nie mogą być użyte jako aktualne wartości priorytetu wątku - nie przekazuj tych wartości jako argumentu priority do funkcji spawn_thread().


Wartości priorytetu wątku

Priorytet współdzielenia czasu (time-sharing) Wartość
B_LOW_PRIORITY 5
B_NORMAL_PRIORITY 10
B_DISPLAY_PRIORITY 15
B_URGENT_DISPLAY_PRIORIT Y 20

Priorytet czasu rzeczywistego Wartość
B_REAL_TIME_DISPLAY_PRIORITY 100
B_URGENT_PRIORITY 110
B_REAL_TIME_PRIORITY 120

Wartości priorytetu wątku są używane do ustawienia "pilności" wątku. Chociaż możesz ponownie ustawić priorytet wątku poprzez set_thread_priority(), priorytet jest początkowo - i prawie zawsze trwale - ustawiany w funkcji spawn_thread(). Jak pokazano tutaj, są dwa typy:


thread_state

enum { ... } thread_state

Stan Znaczenie
B_THREAD_RUNNING Wątek aktualnie otrzymuje uwagę od CPU.
B_THREAD_READY Wątek czeka na powrót aby otrzymać swoją porcję uwagi CPU.
B_THREAD_SUSPENDED Wątek był uśpiony lub jest świeżo zapoczątkowany i oczekuje na start.
B_THREAD_WAITING Wątek oczekuje na przejęcie semafora. Pole sem struktury wątku thread_info powie Ci który to semafor.
B_THREAD_RECEIVING Wątek przebywa w wywołaniu funkcji receive_data().
B_THREAD_ASLEEP Wątek przebywa w wywołaniu funkcji snooze().

Stan wątku mówi Ci co wątek aktualnie robi. Aby uzyskać stan wątku, podglądnij pole state w strukturze thread_info (zwracanej poprzez funkcję get_thread_info()).


Be Book Kernel Kit Kernel Kit Indeks

Be Book,
...w ślicznym HTML...
dla BeOS wydanie 5

Copyright © 2000 Be, Inc. Wszelkie prawa zastrzeżone.