Wielowątkowość – podstawowe informacje

Pojęcie wielowątkowościwielowątkowośćwielowątkowości oznacza złożoną pracę systemu operacyjnego. Dzięki temu w ramach jednego procesuprocesprocesu może zostać wykonane kilka zadań, zwanych wątkami. W e‑materiale wyjaśnimy, czym charakteryzują się wątki w procesie.

Definicja procesu

Pojedyncza instancja programu to proces, który może inicjować inne procesy wzajemnie się ze sobą komunikujące. W każdym z nich musi zachodzić co najmniej jeden wątek, choć może być ich nawet kilkadziesiąt czy kilkaset – w zależności od potrzeb i możliwości maszyny. Wszystkie programy, które tworzyliśmy w innych e‑materiałach, powstawały w ramach jednego wątku i jednego procesu.

W momencie, gdy uruchamialiśmy napisany przez nas program, tworzyliśmy proces, w ramach którego wątek sekwencyjnie wykonywał kolejne wprowadzone przez nas polecenia.

Podstawowe informacje o wątkach w procesie

Wprowadzenie do procesu większej liczby wątków we współczesnych komputerach pozwala na przyspieszenie działania programów – wynika to z efektywniejszego wykorzystywania zasobów procesora. Nie będziemy jednak dociekać, dlaczego stosowanie wielu wątków jest szybsze, ponieważ musielibyśmy opowiedzieć o architekturze procesorów, co nie jest tematem tego e‑materiału. W tym momencie musimy wiedzieć, że w każdym procesie system operacyjny może uruchomić wiele wątków, realizujących osobne zadania. Wątki wykonywane są jednocześnie (współbieżnie). W przypadku gry, którą będziemy projektować w kolejnych e‑materiałach, osobne wątki posłużą nam do obsługi zadań takich jak sterowanie, czy wyświetlanie węża na ekranie.

Wątki, co do zasady, współdzielą pamięć w ramach jednego procesu. Oznacza to, że liczba wcześniej zmodyfikowana przez jeden wątek, w innym wątku będzie poprawnie odczytywana – program pobierze już nową wartość. Jednak bez poprawnie zaimplementowanych mechanizmów synchronizacjimechanizm synchronizacjimechanizmów synchronizacji możemy spowodować tzw. wyścigwyścigwyścig. Załóżmy, że mamy dwa wątki, które pracują na wspólnej puli zmiennych. Oba wątki wykonują się w tym samym czasie.

a = 0
b = 2
c = a + b
c = c + b
wypisz c

Rozważmy to na zaprezentowanym przykładzie. W programie jednowątkowym wynik przedstawionego algorytmu jest oczywisty, na wyjściu zostanie wypisana liczba 4.

Jednak gdy dwa wątki równocześnie wykonują operacje na tych danych, wtedy wynik nie będzie jednoznaczny i możliwe, że będzie się różnił przy każdym uruchomieniu programu.

Nazwijmy nasze wątki A i B, a zapis A:N będzie oznaczać, że wątek A wykonuje n‑tą linijkę, np. A:3 oznacza, że wątek A wykonał linijkę trzecią.

Przeanalizujmy działanie programu:

A:1 a = 0
B:1 a = 0
A:2 b = 2
B:2 b = 2
A:3 c = 0 + 2 = 2
B:3 c = 0 + 2 = 2
A:4 c = 2 + 2 = 4
B:4 c = 4 + 2 = 6
A:5 wypisz 6
B:5 wypisz 6

Wynikiem programu, który wykonywałby się w taki sposób, byłoby wypisanie na ekranie dwóch wartości 6. Taka sytuacja (idealnie synchronicznego działania obu wątków) jest nieosiągalna bez zastosowania mechanizmów synchronizacji. W praktyce bowiem niezsynchronizowane wątki będą walczyć o zasoby, przez co równie dobrze program mógłby wyglądać tak:

A:1 a = 0
A:2 b = 2
A:3 c = 0 + 2 = 2
A:4 c = 2 + 2 = 4
A:5 wypisz 4

B:1 a = 0
B:2 b = 2
B:3 c = 0 + 2 = 2
B:4 c = 2 + 2 = 4
B:5 wypisz 4

Lub w dowolnej innej kombinacji, w której – w ramach jednego wątku – kolejne instrukcje wykonują się po kolei.

Wyścig może jednak zakończyć się negatywnymi skutkami, gdy wątki wzajemnie nadpiszą swoje wyniki.

Załóżmy, że w procesorze jednocześnie wykonuje się A:3 i B:3. Obydwa korzystają z tego samego c jako zmiennej wejściowej i obydwie zapiszą wynik w tym samym miejscu pamięci, co da nam jeszcze inny wynik tegoż wyścigu.

Nie będziemy analizować, który wątek (i w jakim momencie) otrzyma przydział do procesora. Potrzebujemy jedynie podstawowej wiedzy o wątkach.

W większości – jeżeli nie we wszystkich – językach programowania, które implementują wątki, występuje funkcja, która zatrzymuje wykonanie wątku nadrzędnego aż do chwili zakończenia bieżącego wątku. W językach Java, Python i C++ metoda ta nazywa się identycznie – join(). Jest ona przydatna w sytuacji, gdy dalsze operacje w programie chcemy wykonywać dopiero po zakończeniu wątku.

W programowaniu istnieją też inne rozwiązania tego problemu.

Wątki w języku Java

W języku Java wątki możemy stworzyć przez implementację w klasie interfejsu Runnable lub poprzez dziedziczenie po klasie Thread. Efekt działania obu rozwiązań jest taki sam, ale różnią się one znacznie pod względem sposobu kodowania. Zasadnicza różnica polega na tym, że dziedzicząc po klasie Thread, blokujemy możliwość dalszego dziedziczenia (Java nie obsługuje wielokrotnego dziedziczenia). Innymi słowy, jeżeli klasa będzie dziedziczyła po klasie Thread, to nie może już dziedziczyć po żadnej innej.

Natomiast interfejs Runnable implementujemy w konkretnej klasie, na podstawie której możemy utworzyć wiele obiektów. Nie blokujemy żadnych możliwości dziedziczenia. Dodatkowo mamy możliwość dodawania do klasy dalszych interfejsów, jeżeli zajdzie taka potrzeba. W przypadku naszego prostego przykładu nie ma jednak znaczenia, którą drogę realizacji wybierzemy.

Warto jeszcze uzupełnić, że klasa Thread jest standardową klasą reprezentującą wątek w języku Java. Udostępnia kilka ważnych i przydatnych metod oraz właściwości. Na potrzeby tego materiału poznamy tylko część najistotniejszych, niezbędnych do wykorzystania tej klasy w praktyce.

Najważniejsza w klasie Thread jest metoda run(), w niej znajduje się kod, który będzie realizowanym przez wątek. Jego działanie rozpoczyna się po wywołaniu innej należącej do klasy Thread metody, czyli start(). Krótko mówiąc wątek uruchamiamy, wywołując metodę start() i rozpoczyna on realizowanie kodu zawartego w metodzie run(). Dlatego właśnie implementując własny wątek przez dziedziczenie klasy Thread, przesłaniamy metodę run() i zapewniamy w klasie potomnej jej własną implementację.

Inną ważną metodą jest join(). Wywołując tę metodę, będziemy mogli zaimplementować oczekiwanie na zakończenie wątku. W klasie Thread znajdziemy jeszcze inne przydatne metody. Na przykład metoda sleep() pozwala na uśpienie (zatrzymanie) wątku na określony czas. W omawianym przykładzie ograniczymy się jednak do zastosowania podstawowych metod.

Sprawdźmy najpierw, czy rzeczywiście zjawisko wyścigów funkcjonuje w języku Java. Do tego posłuży kod, który w linijkach 5–9 tworzy nowe obiekty klasy Thread za pomocą konstruktora LicznikThread.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Licznik licznik = new Licznik();
        int n = 10;
        Thread[] watek = new Thread[n];
        for(int i = 0; i<n; i++){
            watek[i] = new LicznikThread(licznik);
            watek[i].start();
        }
        for(int i = 0; i<n; i++){
            watek[i].join();
        }
        System.out.println(licznik.wyswietlWartosc());
    }
}

Możemy tak zrobić, ponieważ klasa LicznikThread dziedziczy po klasie Thread.

class LicznikThread extends Thread {
    private Licznik licznik;

    public LicznikThread(Licznik counter) {
        this.licznik = counter;
    }

    public void run() {
        for ( int i=0; i<100000; i++ ) {
            licznik.zwieksz();
        }
    }
}

Metoda run() domyślnie występuje w klasie Thread i w linijce ósmej ją nadpisujemy (przesłaniamy). Jak już wspomnieliśmy wyżej, metoda run() zawiera kod, który będzie wykonywany w ramach wątku.

Metoda start() służy do uruchamiania wątku, a metodę join() wykorzystamy do tego, aby uzyskać pewność, że wszystkie wystartowane wątki się zatrzymały, zanim zaczniemy dalej wykonywać kod. Po wywołaniu metoda join() kończy swoje działanie (nie zwracając żadnej wartości) w momencie, gdy wątek, dla którego obiektu ją wywołaliśmy, zakończył pracę.

class Licznik {
    private int c = 0;
    public  void zwieksz() {
        c++;
    }
    public  int wyswietlWartosc() {
        return c;
    }
}

Klasa licznik zawiera w sobie wartość c, którą zmienia metoda zwieksz(). To właśnie w tej metodzie dochodzi do wyścigu.

Oto cały kod, który należy uruchomić na własnym komputerze kilka razy i sprawdzić, czy wyniki rzeczywiście są różne.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Licznik licznik = new Licznik();
        int n = 10;
        Thread[] watek = new Thread[n];
        for(int i = 0; i<n; i++){
            watek[i] = new LicznikThread(licznik);
            watek[i].start();
        }
        for(int i = 0; i<n; i++){
            watek[i].join();
        }
        System.out.println(licznik.wyswietlWartosc());
    }
}
class LicznikThread extends Thread {
    private Licznik licznik;

    public LicznikThread(Licznik counter) {
        this.licznik = counter;
    }

    public void run() {
        for ( int i=0; i<100000; i++ ) {
            licznik.zwieksz();
        }
    }
}
class Licznik {
    private int c = 0;
    public  void zwieksz() {
        c++;
    }
    public  int wyswietlWartosc() {
        return c;
    }
}

Jak już wspomniano, jednym z ograniczeń języka Java jest to, że może on dziedziczyć jedynie po jednej klasie jednocześnie, dlatego też dziedziczenie po Thread w klasie LicznikThread jest może i dobrym pomysłem w ramach omawianego prostego przykładu, ale w ten sposób bardzo mocno ograniczamy możliwości projektowania klas.

Z tego powodu kod lepiej napisać, wykorzystując drugą metodę, tj. interfejs Runnable(). Dzięki temu nie zablokujemy możliwości dziedziczenia. Kod wówczas będzie wyglądał następująco:

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Licznik licznik = new Licznik();
        int n = 10;
        Thread[] watek = new Thread[n];
        for(int i = 0; i<n; i++){
            watek[i] = new Thread(new LicznikRunnable(licznik));
            watek[i].start();
        }
        for(int i = 0; i<n; i++){
            watek[i].join();
        }
        System.out.println(licznik.wyswietlWartosc());
    }
}
class LicznikRunnable implements Runnable {
    private Licznk licznik;

    public LicznikRunnable(Licznik counter) {
        this.licznik = counter;
    }

    public void run() {
        for ( int i=0; i<100000; i++ ) {
            licznik.zwieksz();
        }
    }
}

class Licznik {
    private int c = 0;
    public  void zwieksz() {
        c++;
    }
    public  int wyswietlWartosc() {
        return c;
    }
}

Korzystając z interfejsu Runnable, również obowiązkowo przesłaniamy (nadpisujemy) metodę run(), w której zawarty jest kod wykonywany w ramach wątku. Jest on stworzony z myślą o klasie Thread. Klasa Thread w konstruktorze przyjmuje obiekt klasy implementującej interfejs Runnable i zawierającej w sobie nadpisaną (realizującą wymagane przez nas zadania) metodę run().

Żeby uniknąć wyścigu, możemy w języku Java użyć słowa kluczowego Synchronized, dzięki któremu dana metoda będzie wykonywana tylko przez jeden wątek w określonym momencie.

class Licznik {
    private int c = 0;
    public synchronized void zwieksz() {
        c++;
    }
    public  int wyswietlWartosc() {
        return c;
    }
}

Po zmodyfikowaniu klasy Licznik, przez dodanie słowa kluczowego Synchronized, wynikiem programu jest liczba 1000000 za każdym uruchomieniem.

W dalszej części e‑materiału wyjaśnione zostanie działanie tego słowa kluczowego.

Mechanizm semaforów

Alternatywnie możemy skorzystać z mechanizmów semaforów lub muteksów. Wybieramy te pierwsze. Różnica między nimi jest taka, że semafory mogą być podnoszone przez dowolny wątek, natomiast muteksy jedynie przez te, które je zamknęły. Jeśli wątek próbuje przejść przez zamknięty semafor, to czeka, aż ten się otworzy. Jeśli wiele wątków czeka na otwarcie semafora, to wtedy tylko jeden z nich, losowy, przejdzie przez niego, jednocześnie go opuszczając. Pozostałe będą dalej czekać.

Obiekt klasy Semaphore tworzymy w następujący sposób:

Semaphore semafor = new Semaphore(1);

W konstruktorze jako argument podajemy, ile wątków może przez niego przejść, zanim ten się definitywnie zamknie. W omawianym wypadku będzie to właśnie 1.

Próba zajęcia semafora przez wątek może wywołać wyjątek InterruptedException, więc użyjemy try/catch, żeby go obsłużyć.

Metoda acquire() z klasy Semaphore służy do opuszczania, a w zasadzie do zmniejszania liczby „zgód” na wejście wątku w dane miejsce. Jeśli liczba ta wyniesie 0, to semafor uznajemy za zamknięty.

Metoda release() z kolei podnosi liczbę „zgód” na wejście wątków w daną sekcję krytyczną.

class Licznik {
    private int c = 0;
    Semaphore semafor = new Semaphore(1);
    public void zwieksz() {
        try {
            semafor.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        c++;
        semafor.release();
    }
    public  int wyswietlWartosc() {
        return c;
    }
}

Pokazaliśmy więc, jak wyglądałaby klasa Licznik, gdybyśmy do synchronizacji użyli semaforów.

Monitor na obiektach

W języku Java istnieje wiele możliwości synchronizacji wątków. Podczas omawiania tego tematu należy koniecznie wspomnieć, że każdy tworzony obiekt dziedziczy swoje właściwości po klasie Object(), w której są zawarte, m.in. takie metody jak:
wait(), notify() oraz notifyAll().

Każdy obiekt w języku Java posiada wbudowany w siebie monitor, inaczej mówiąc zamek, który kontrolowany jest za pomocą wyżej wymienionych funkcji.

Pierwsza ze wspomnianych metod zatrzymuje pracę wątku do czasu otrzymania przez obiekt (zamek), podawanego jako argument, stosownego komunikatu.

Druga ze wspomnianych metod wysyła pojedynczy komunikat przechwytywany przez jeden czekający wątek, który oczekuje na odblokowanie konkretnego zablokowanego obiektu (zamka). Jeżeli żaden wątek z danym zamkiem nie czeka, to operacja ta nie ma w praktyce żadnych efektów.

Trzecia ze wspomnianych metod wysyła komunikat do wszystkich wątków czekających na odblokowanie zamka danego obiektu. Podobnie jak w przypadku notify(), jeżeli żaden wątek nie czeka na odblokowanie tego zamka, to operacja ta nie ma efektu.

W momencie używania słowa kluczowego synchronized() w definicji metody, wspomniany monitor też jest używany. Warto tutaj dodać, że sformułowanie takie jak:

void synchronized przyklad(){

}

Działałby identycznie jak:

void przyklad(){
	synchronized(this){
    
    }
}

Aby skorzystać z wyżej wymienionych metod, należy użyć ich w ramach bloku synchronized() i wskazać obiekt, na którym chcemy założyć wspominany zamek.

Czyli żeby skorzystać z metody wait(), w ramach przykładowej metody zrealizowalibyśmy to w następujący sposób:

void przyklad(Object zamek){
	synchronized(zamek){
    	zamek.wait();
    }
}

Wtedy też moglibyśmy użyć obiektu zamek klasy Object w sposób podobny do semaforów. Różnicą pomiędzy tymi dwoma rozwiązaniami jest to, że metoda notify() nie zapisuje „zgód” na zapas, to znaczy możliwe jest, że metoda ta nie spowoduje, że uruchomi się jakiś wątek, ponieważ żaden wątek nie będzie oczekiwał na ten komunikat. Dlatego też warunkiem efektywności metody notify(), jest to, żeby w czasie jej wykonywania jakiś wątek oczekiwał na komunikat przez nią wysyłany.

Przykład realizujący zadanie analogiczne do powyższego wyglądałby następująco:

public class Main {
    public static void main(String[] args) throws InterruptedException {

        int n = 50; //liczba uruchamianych 50 wątków.
        Thread[] watek = new Thread[n];
        LicznikWrapper obiektZawierajacyLicznik = new LicznikWrapper();
        for(int i = 0; i<n; i++){
            watek[i] = new Thread(new Wyswietlacz(i, obiektZawierajacyLicznik));
            watek[i].start();
        }

        for(int i = 0; i<1000; i++){
            synchronized (obiektZawierajacyLicznik) {
                obiektZawierajacyLicznik.notify(); //wznawiamy wątek używający jako zamka obiektu zawierającego licznik
                //o ile jakiś na to oczekuje
            }
        }
        for(int i = 0; i<n; i++){
            watek[i].interrupt(); //informujemy wątek, że już nie musi pracować
            watek[i].join();
        }
        System.out.println("Ostateczna wartosc obiektu licznik klasy Integer to: " + obiektZawierajacyLicznik.licznik);
    }
}

class LicznikWrapper
{
    int licznik = 0;
}

class Wyswietlacz implements Runnable
{
    int numerWatku = -1;
    final LicznikWrapper obiektZawierajacyLicznik;
    Wyswietlacz(int numerWatku,LicznikWrapper obiektZawierajacyLicznik) {
        this.numerWatku = numerWatku;
        this.obiektZawierajacyLicznik = obiektZawierajacyLicznik;
    }
    @Override
    public void run() {
        while(true){
            synchronized(obiektZawierajacyLicznik)
            {
                try {
                    obiektZawierajacyLicznik.wait();
                    obiektZawierajacyLicznik.licznik++;
                    System.out.println("Watek numer " + numerWatku + " a licznik to " + obiektZawierajacyLicznik.licznik);
                } catch (InterruptedException e) {
                    break; //Koniecznie potrzebne, ponieważ robimy ręcznie
                    //interrupt na wszystkich wątkach, by te zakończyły swoją pracę po 1000 wykonań.
                }
            }
        }
    }
}

Podkreślmy, że niezapisywanie przez notify() nadmiarowych „zgód” (czy w tym przypadku komunikatów), wcale nie jest wadą tego mechanizmu, tylko jego cechą. Przykładowo program, w którym realizowalibyśmy symulację wsiadania pasażerów do pociągu, przy pewnych założeniach, mógłby być prostszy do zaimplementowania z użyciem metod notifyAll() i wait(), niż semaforów. W takim programie wątki byłyby pasażerami, czekającymi na wjazd pociągu na peron. Oznacza to, że każdy z obiektów klasy pasażer byłby osobnym wątkiem, wykonującym – na obiekcie klasy peron – metodę wait(). Z kolei pociąg wykonałby metodę notifyAll() (na wspominanym wcześniej peronie), żeby powiadomić wszystkich pasażerów, że już nadjechał i można do niego wsiadać. Następnie pasażerowie wchodziliby do pociągu do momentu, gdy skończyłoby się w nim miejsca lub nie byłoby już więcej oczekujących pasażerów. Wtedy pociąg odjeżdżałby, a kolejni pasażerowie, którzy dopiero przybyliby na peron, musieliby oczekiwać na kolejny pociąg.

Dlatego też mechanizmów synchronizacji należy używać zależnie od potrzeby.

Współbieżność w C++

W języku C++ współbieżność można zaimplementować na kilka sposobów. Zrobimy to z pomocą biblioteki thread, dołączonej do języka C++11. Podstawową klasą obsługującą wątki jest w tej bibliotece klasa thread. Obiekt tej klasy reprezentuje pojedynczy wątek.

Istnieje analogiczna biblioteka, która wywodzi się jeszcze z języka C, czyli pthread, której jednak nie będziemy omawiać.

Konstruktor klasy thread jako pierwszy parametr przyjmuje wskaźnik do funkcji, która będzie realizowana w ramach wątku, a kolejne argumenty konstruktora to po prostu argumenty tej funkcji. Zamiast funkcji można użyć również klasy, co wyjaśnimy  dalej.

Poniżej możemy zobaczyć przykład najprostszego programu wykorzystującego wątki. W ramach każdego wątku wykonywana jest funkcja zwieksz(), która jako argument przyjmuje wskaźnik do liczby, którą potem zwiększa o n. Konstruktor wątku przyjmuje jako argument jej nazwę. W przykładzie uruchamianych jest n wątków, których obiekty przechowywane są w tablicy th[].

#include <iostream>
#include <thread>
using namespace std;
const int n = 5000;
void zwieksz(int *c) {
	for(int i = 0; i<n; i++)
	{
		(*c)++;
	}	
}
int main()
{	
	int c = 0;
	thread th[n];
	 
	for (int i = 0; i < n; i++) 
	{
		th[i] = thread(zwieksz, &c);
	}
	for (int i = 0; i < n; i++)
	{
		th[i].join();
	}
	cout << c;
}

Obiekt klasy thread od razu po utworzeniu włącza się i zaczyna pracę, nie ma więc potrzeby pobudzania go. Natomiast funkcja join() klasy thread pozwala na zatrzymanie pracy głównego programu aż do chwili ukończenia działania wątku. Nie zwraca ona żadnej wartości, ale kończy działanie wraz z zakończeniem pracy wątku.

Przykład ten pokazuje możliwość przekazania do wątku klasy zamiast funkcji. W takim przypadku pierwszym argumentem konstruktora obiektu thread powinien być operator() danej klasy. Przykład realizuje to samo proste zadanie, co kod powyżej, tyle że zwiększanie liczby o n dokonywane jest w klasie Przyklad, zamiast w funkcji zwieksz().

#include <iostream>
#include <thread>
using namespace std;
const int n = 5000;

class Przyklad {
public:
	void operator()(int* c)
	{
		for (int i = 0; i < n; i++)
		{
			(*c)++;
		}
	}
};

int main()
{	
	int c = 0;
	thread th[n];
	for (int i = 0; i < n; i++) 
	{
		th[i] = thread(Przyklad(), &c);
	}
	for (int i = 0; i < n; i++)
	{
		th[i].join();
	}
	cout << c;
}

W kolejnym przykładzie zobaczymy, w jaki sposób do konstruktora klasy thread można przekazać więcej zmiennych. Kod realizuje podobne zadanie jak poprzednie, przy czym tym razem w klasie Przyklad przeliczane są trzy zmienne: pierwsza jest zwiększana n razy, druga jest zmniejszana n razy, a trzecia – jest n razy powiększana o 2. Do konstruktora obiektu wątku przekazywane są więc trzy wskaźniki do zmiennych.

#include <iostream>
#include <thread>
using namespace std;

const int n = 5000;

class Przyklad {
public:
	void operator()(int* c, int *d, int *f)
	{
		for (int i = 0; i < n; i++)
		{
			(*c)++;
			(*d)--;
			*f += 2;
		}
	}
};

int main()
{	
	int c = 0;
	int d = 0;
	int f = 0;
	thread th[n];
	for (int i = 0; i < n; i++) 
	{
		th[i] = thread(Przyklad(), &c, &d, &f);
	}
	for (int i = 0; i < n; i++)
	{
		th[i].join();
	}
	cout << c << endl;
	cout << d << endl;
	cout << f << endl;
}

W tej bibliotece nie istnieje wbudowana możliwość automatycznego synchronizowania metod jak w języku Java. Nie oznacza to jednak, że nie można synchronizować w niej wątków. Można zrobić to w sposób programowy czy choćby przez stosowanie muteksów lub semaforów.

Muteksy i semafory są podobne, ale nie można używać ich wymiennie.

Mechanizmy muteksów

Użyjemy muteksów, które charakteryzują się tym, że tylko jeden wątek może znajdować się w sekcji krytycznejsekcja krytycznasekcji krytycznej. Warto dodać, że każdy mutex musi być opuszczony i podniesiony przez ten sam wątek i niemożliwa jest sytuacja, w której dwa wątki będą operować w sekcji krytycznej ograniczonej właśnie przez mutex.

Muteksy są dostępne w bibliotece <mutex>, będącej w standardzie od C++11.

Warto dodać, że semafory zostały wprowadzone po raz pierwszy w standardzie C++20.

mutex zamek;
class Przyklad {
public:
	void operator()(int* c, int* d, int* f)
	{
		zamek.lock();
		for (int i = 0; i < n; i++)
		{
			(*c)++;
			(*d)--;
			*f += 2;
		}
		zamek.unlock();
	}
};

Jeśli zapiszemy kod w ten sposób, otrzymamy następujący wydruk:

25000000
-25000000
50000000

Dzieje się tak, ponieważ dzięki naszemu zamkowi tylko jeden wątek na raz może znajdować się w sekcji krytycznej.

Współbieżność w języku Python

W języku Python za współbieżność odpowiada klasa Thread, dostępna w bibliotece  threading. Klasa ta ma w swoim konstruktorze dwa argumenty, które nas interesują. Pierwszym z nich jest argument target, za pomocą którego wskazujemy funkcję lub metodę, w której dany wątek rozpocznie pracę. Drugim jest argument args(), w którym wpisujemy argumenty funkcji wskazanej w pierwszym argumencie. Argumenty wpisujemy w tej samej kolejności, w jakiej pojawiają się w definicji funkcji lub metody.

Za pomocą kodu możemy zasymulować zjawisko wyścigu:

import threading
x = 0;
def przyklad():
    zwieksz()
    return
def zwieksz():
    for _ in range(100000):
        global x;
        x = x + 2;
threads = []
for i in range(1000):
    t = threading.Thread(target=przyklad)
    threads.append(t)
for i in range(1000):
    threads[i].start();
for i in range(1000):
    threads[i].join();
print(x);

W 12. wierszu rozpoczynamy działanie nowych wątków, które za argument przyjmują funkcję przyklad(). Następnie wszystkie są uruchamiane metodą start() w 15. wierszu. Ważne, żeby uruchomić stworzone wątki – jeśli tego nie zrobimy, nie zaczną pracy. Ostatnią metodą z klasy Thread, którą omówimy, będzie join(). Metoda ta służy do upewniania się, że – do tego momentu – wątek zakończył swoje działanie. Jeśli dany wątek nie zakończył działania, cały program czeka, aż ten się zakończy. Jeżeli nie będziemy używać tej metody, program może zakończyć swoje działanie zbyt wcześnie - przed zakończeniem wszystkich wątków. W naszym przykładzie bez linijek 16–17 istnieje szansa, że linijka 18 wykona się, zanim wszystkie wątki zakończą działanie, co z kolei wypisze nam zły wynik.

Jak zapobiec wyścigowi?

Wyścig, zgodnie z tym, co zostało opisane wcześniej, jest zjawiskiem nieprzewidywalnym z perspektywy programisty. Aby mu zapobiec, skorzystamy z threading.Lock(), czyli z klasy dostępnej z biblioteki threading.

Możemy skorzystać również z semaforówsemaforysemaforów, czy innych form zarządzania sekcjami krytycznymisekcja krytycznasekcjami krytycznymi, jednakże w tym e‑materiale ograniczymy się tylko do zamków.

W języku Python klasa threading.Lock() może być otwierana i zamykana przez dowolny wątek. Oznacza to, że jeden wątek może zamknąć sekcje krytyczną, a drugi ją otworzyć bez zgody poprzedniego – co w zależności od sytuacji może być pożądane lub nie.

Do zamykania używamy metody acquire(), a do otwierania metody release(). Metoda acquire() może przyjmować argumenty, które dodatkowo zmodyfikują zachowanie zamka.

Sam zamek tworzymy w następujący sposób:

zamek = threading.Lock();

Tam zamek zamykamy:

zamek.acquire();

Tak otwieramy:

zamek.release();

Kod z użyciem zamków mógłby wyglądać w następujący sposób:

import threading
x = 0;
zamek = threading.Lock();

def przyklad():
    zwieksz()
    return


def zwieksz():
    zamek.acquire();
    for _ in range(100000):
        global x;
        x = x + 2;
    zamek.release();

threads = []
for i in range(1000):
    t = threading.Thread(target=przyklad)
    threads.append(t)
for i in range(1000):
    threads[i].start();
for i in range(1000):
    threads[i].join();
print(x);

Dzięki zamkowi mamy pewność, że nie dojdzie do wyścigu. Oznacza to, że za każdym uruchomieniem programu zostanie wypisane „200000000”.

Słownik