lab1-report/lab1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Treść zadania\n",
    "\n",
    "1. Napisać program, który uruchamia 2 wątki, z których jeden zwiększa wartość zmiennej\n",
    "   całkowitej o 1, drugi wątek zmniejsza wartość o 1. Zakładając, że na początku wartość\n",
    "   zmiennej Counter była 0, chcielibyśmy wiedzieć jaka będzie wartość tej zmiennej po\n",
    "   wykonaniu 10000 operacji zwiększania i zmniejszania przez obydwa wątki.  \n",
    "\n",
    "2. Na podstawie 100 wykonań programu z p.1, stworzyć histogram końcowych wartości\n",
    "   zmiennej Counter.\n",
    "\n",
    "3. Spróbować wprowadzić mechanizm do programu z p.1, który zagwarantowałby przewidywalną\n",
    "   końcową wartość zmiennej Counter. Nie używać żadnych systemowych mechanizmów, tylko\n",
    "   swój autorski.\n",
    "\n",
    "4. Napisać sprawozdanie z realizacji pp. 1-3, z argumentacją i interpretacją wyników.\n",
    "\n",
    "# Rozwiązanie\n",
    "\n",
    "Poniżej znajdują się 2 rozwiązania: pierwsze jest implementacją punktów 1 i 2, z kolei\n",
    "drugie jest realizacją punktu 3.\n",
    "\n",
    "## Race condition (p. 1-2)\n",
    "\n",
    "Poniższe rozwiązanie demonstruje tzw. *Race condition*, czyli *Wyścig*. Jest to zjawisko,\n",
    "które charakteryzuje się niedeterministycznym zachowaniem programu, może powodować błędy\n",
    "trudne do wykrycia i pojawia się wtedy, gdy więcej niż jeden wątek korzysta jednocześnie\n",
    "z zasobu dzielonego, przy czym co najmniej jeden próbuje go zmienić.\n",
    "\n",
    "Żeby zademonstrować to zjawisko, wystarczy zaimplementować prosty licznik, który będzie\n",
    "modyfikowany jednocześnie przez 2 wątki (np. zwiększany przez jeden i zmniejszany przez\n",
    "drugi).\n",
    "\n",
    "Przykładowa implementacja:\n",
    "\n",
    "**Licznik:**\n",
    "\n",
    "```java\n",
    "// Counter.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp.counter;\n",
    "\n",
    "public class Counter {\n",
    "    private int _val;\n",
    "\n",
    "    public Counter(int n) {\n",
    "        _val = n;\n",
    "    }\n",
    "\n",
    "    public void inc() {\n",
    "        _val++;\n",
    "    }\n",
    "\n",
    "    public void dec() {\n",
    "        _val--;\n",
    "    }\n",
    "\n",
    "    public int value() {\n",
    "        return _val;\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Wątek zmniejszający licznik:**\n",
    "\n",
    "```java\n",
    "// DThread.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp;\n",
    "\n",
    "import pl.edu.agh.tw.knapp.counter.Counter;\n",
    "\n",
    "public class DThread extends Thread {\n",
    "    private final int count;\n",
    "\n",
    "    private Counter counter;\n",
    "\n",
    "    public DThread(int count) {\n",
    "        this.count = count;\n",
    "    }\n",
    "\n",
    "    public void setCounter(Counter counter) {\n",
    "        this.counter = counter;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void run() {\n",
    "        for (int i = 0; i < count; i++) {\n",
    "            counter.dec();\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Wątek zwiększający licznik:**\n",
    "\n",
    "```java\n",
    "// IThread.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp;\n",
    "\n",
    "import pl.edu.agh.tw.knapp.counter.Counter;\n",
    "\n",
    "public class IThread extends Thread {\n",
    "    private final int count;\n",
    "\n",
    "    private Counter counter;\n",
    "\n",
    "    public IThread(int count) {\n",
    "        this.count = count;\n",
    "    }\n",
    "\n",
    "    public void setCounter(Counter counter) {\n",
    "        this.counter = counter;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void run() {\n",
    "        for (int i = 0; i < count; i++) {\n",
    "            counter.inc();\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Głowna klasa:**\n",
    "\n",
    "```java\n",
    "package pl.edu.agh.tw.knapp;\n",
    "\n",
    "import pl.edu.agh.tw.knapp.counter.Counter;\n",
    "\n",
    "public class Race {\n",
    "    public static void main(String[] args) throws InterruptedException {\n",
    "        final int operationCount = 10_000;\n",
    "\n",
    "        var incThread = new IThread(operationCount);\n",
    "        var decThread = new DThread(operationCount);\n",
    "\n",
    "        var counter = new Counter(0);\n",
    "\n",
    "        incThread.setCounter(counter);\n",
    "        decThread.setCounter(counter);\n",
    "\n",
    "        incThread.start();\n",
    "        decThread.start();\n",
    "\n",
    "        incThread.join();\n",
    "        decThread.join();\n",
    "\n",
    "        System.out.println(\"stan=\" + counter.value());\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "> Uwaga 1: klasy `DThread` i `IThread` można zgeneralizować (tzn. stworzyć wspólną\n",
    "> klasę nadrzędną, ale w celach czytelności to zostało pominięte).\n",
    "\n",
    "> Uwaga 2: wyniki znajdują się w rozdziale \"Wyniki\"\n",
    "\n",
    "## Synchronizacja wątków (p. 3)\n",
    "\n",
    "Synchronizacji wątków można dokonać na wiele sposobów, przede wszystkim użyć mechanizmów\n",
    "wbudowanych, np. mutexów, atomiców, lockerów, `synchronized` itd., ale to zadanie musi\n",
    "zostać wykonane bez korzystania z w/w mechanizmów.\n",
    "\n",
    "W przypadku prostego licznika, nie korzystając w mechanizmów systemowych, możemy otrzymać\n",
    "przewidywalną wartość na kilka sposobów:\n",
    "\n",
    "1. Drugi wątek zostanie uruchomiony po zakończeniu pierwszego - w tym przypadku dostaniemy\n",
    "   przewidywalną wartość (czyli 0), lecz to rozwiązanie jest równoważne inkrementacji i\n",
    "   dekrementacji licznika w jednym wątku;\n",
    "\n",
    "2. Każdy wątek dostaje na wejściu kopię (klona) licznika, i wykonuje na nim swoje operacje.\n",
    "   Następnie główny wątek mergeuje wyniki (inaczej mówiąc - dodaje wartości liczników).\n",
    "   Takiego rozwiązania można użyć, ale ono nie pokazuje jednoczesnego korzystania z zasobu\n",
    "   dzielonego - licznika;\n",
    "\n",
    "3. Własny mechanizm synchronizacji, który w *jakimś* stopniu będzie działał podobnie do mutexa.\n",
    "   To rozwiązanie zostanie zaimplementowane poniżej.\n",
    "\n",
    "W celu implementacji własnego mechanizmu synchronizacji, musimy najpierw zrozumieć, jak wygląda\n",
    "dostęp do zmiennych w przypadku wielowątkowości.\n",
    "\n",
    "### Przykład\n",
    "\n",
    "Rozważmy następujący przykład:\n",
    "\n",
    "```java\n",
    "public class TaskRunner {\n",
    "\n",
    "    private static int number;\n",
    "    private static boolean ready;\n",
    "\n",
    "    private static class Reader extends Thread {\n",
    "\n",
    "        @Override\n",
    "        public void run() {\n",
    "            while (!ready) {\n",
    "                Thread.yield();\n",
    "            }\n",
    "\n",
    "            System.out.println(number);\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        new Reader().start();\n",
    "        number = 42;\n",
    "        ready = true;\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "Oczekujemy, że wątek `Reader` wypisze `42`, ale w rzeczywistości niekoniecznie tak się stanie.\n",
    "Program może się zawiesić, wypisać wynik po jakimś czasie, a nawet możemy dostać na wyjściu `0`.\n",
    "To się dzieje z różnych powodów, między innymi: optymalizacje (out-of-order execution,\n",
    "`ready = true` może zostać wykonane przed `number = 42`), caching (na systemach wielordzeniowych,\n",
    "każdy rdzeń posiada własną pamięć podręczną w celu przyspieszenia działania).\n",
    "\n",
    "### Słowo kluczowe `volatile`\n",
    "\n",
    "Aby zapewnić, że aktualizacje zmiennych przekazywane są przewidywalnie do innych wątków, powinniśmy\n",
    "zastosować modyfikator `volatile` do tych zmiennych. Tzn., w przypadku w/w przykładu:\n",
    "\n",
    "```java\n",
    "public class TaskRunner {\n",
    "\n",
    "    private static volatile int number;\n",
    "    private static volatile boolean ready;\n",
    "\n",
    "    // ...\n",
    "\n",
    "}\n",
    "```\n",
    "\n",
    "Stosując dane podejście, wszelkie zmiany dokonane na tych zmiennych będą przekazywane do innych wątków.\n",
    "\n",
    "### Implementacja\n",
    "\n",
    "Moja własna implementacja posiada następujący interfejs:\n",
    "\n",
    "```java\n",
    "// ILocker.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp.locker;\n",
    "\n",
    "public interface ILocker {\n",
    "    void lock();\n",
    "    void unlock();\n",
    "}\n",
    "```\n",
    "\n",
    "Od razu musimy przyjąć pewne założenia:\n",
    "\n",
    "- Kilka wątków może wywołać metodę `lock` jednocześnie;\n",
    "- Tylko jeden wątek może wywołać metodę `unlock` w tym samym czasie;\n",
    "\n",
    "Dodatkowo:\n",
    "\n",
    "- W celu uniknięcia zawieszenia (deadlock), po wywołaniu `lock` musi nastąpić `unlock`;\n",
    "- Metoda `unlock` musi zostać wywołana z tego samego wątku co i `lock`, w przeciwnym przypadku program\n",
    "  może się zachowywać w sposób nieprzywidywalny (undefined behavior);\n",
    "- Wątki będą mogły zablokować Locker w z góry zadanej kolejności;\n",
    "\n",
    "Warto również przypomnieć, że każdy wątek ma swój własny unikalny identyfikator. W Javie możemy go pobrać\n",
    "korzystając z `Thread#getId()`. Żeby otrzymać wątek, w którym wykonuje się dana funkcja, możemy skorzystać z\n",
    "`Thread.currentThread()`.\n",
    "\n",
    "Implementacja własnego lockera:\n",
    "\n",
    "```java\n",
    "// ThreadLocker.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp.locker;\n",
    "\n",
    "import java.util.*;\n",
    "import java.util.stream.Collectors;\n",
    "import java.util.stream.IntStream;\n",
    "\n",
    "public class ThreadLocker implements ILocker {\n",
    "    // <thread id, thread index>\n",
    "    private final Map<Long, Integer> threadIds;\n",
    "\n",
    "    private volatile int activeThreadIndex = 0;\n",
    "\n",
    "    public ThreadLocker(Thread... threads) {\n",
    "        threadIds = IntStream.range(0, threads.length)\n",
    "                .mapToObj(i -> new AbstractMap.SimpleEntry<>(threads[i].getId(), i))\n",
    "                .collect(Collectors.toUnmodifiableMap(\n",
    "                    AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void lock() {\n",
    "        while (!canBeLocked()) {\n",
    "            Thread.yield();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void unlock() {\n",
    "        activeThreadIndex = (activeThreadIndex + 1) % threadIds.size();\n",
    "    }\n",
    "\n",
    "    private boolean canBeLocked() {\n",
    "        var currentThreadIndex = threadIds.get(Thread.currentThread().getId());\n",
    "        return currentThreadIndex == activeThreadIndex;\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "Ten locker działa w następujący sposób:\n",
    "\n",
    "- Tworzymy go przekazując jako argumenty wątki, które będą z niego korzystały;\n",
    "- Każdy taki wątek dostaje indeks;\n",
    "- W celu mapowania id wątku na jego indeks korzystamy z mapy (warto zwrócić uwagę: jest ona *niemodyfikowalna* i oznaczona\n",
    "  jako `final`, a więc możemy bezpiecznie odczytywać z niej wartości z różnych wątków, tzn. nie potrzebujemy żadnej\n",
    "  dodatkowej synchronizacji);\n",
    "- Zmienna `activeThreadIndex` wskazuje, dla którego wątku ten locker może zostać zablokowany;\n",
    "- Metoda `lock` sprawdza, czy locker może zostać zablokowany **dla danego wątku** (mapując *thread id* na *thread index*),\n",
    "  i jeżeli tak, blokuje go przerywając pętlę (warto zauważyć, że ta pętla powoduje tzw. *busy-waiting*, w celu zmniejszenia\n",
    "  (raczej próby zmniejszenia) negatywnych efektów użyto `Thread.yield`);\n",
    "- Metoda `unlock` zwiększa `activeThreadIndex` o 1 (modulo `threadIds.size()`);\n",
    "\n",
    "Dzięki temu, że `activeThreadIndex` jest użyty z modyfikatorem `volatile`, ten mechanizm działa poprawnie, tzn.\n",
    "zgodnie z oczekiwaniami.\n",
    "\n",
    "> Uwaga: wyniki znajdują się w rozdziale \"Wyniki\"\n",
    "\n",
    "#### Zalety\n",
    "\n",
    "- Prosty w implementacji;\n",
    "- Pozwala tworzyć tzw. sekcje krytyczne, dzięki czemu mamy możliwość zsynchronizowania działania kilku wątków;\n",
    "- Łatwy w użyciu - ma interfejs podobny do interfejsu mutexa;\n",
    "\n",
    "#### Wady\n",
    "\n",
    "- Powoduje tzw. **busy-waiting** - ciągłe sprawdzanie, czy Locker jest dostępny dla danego wątku - niepotrzebnie korzystamy\n",
    "  z czasu procesora, który mógłby zostać wykorzystany na wykonanie ważniejszych rzeczy;\n",
    "- Wymaga, aby wątki, które będą korzystały z Lockera, były z góry znane i przekazane do konstruktora;\n",
    "- Zakłada, że wszystkie wątki będą mogły zablokować Lockera w kolejności, w jakiej zostały przekazane do konstruktora. Z tego\n",
    "  wynika, że jeżeli np. wątek A wywołuje `lock` 1000 razy, a wątek B - 998 razy, to program się zawiesi;\n",
    "- Nie nadaje się do praktycznego użycia;\n",
    "\n",
    "Zsynchronizowany (thread-safe) licznik:\n",
    "\n",
    "```java\n",
    "// SynchronizedCounter.java\n",
    "\n",
    "package pl.edu.agh.tw.knapp.counter;\n",
    "\n",
    "import pl.edu.agh.tw.knapp.locker.ThreadLocker;\n",
    "\n",
    "public class SynchronizedCounter extends Counter {\n",
    "    private final ThreadLocker locker;\n",
    "\n",
    "    public SynchronizedCounter(int n, Thread... threads) {\n",
    "        super(n);\n",
    "        locker = new ThreadLocker(threads);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void inc() {\n",
    "        locker.lock();\n",
    "        super.inc();\n",
    "        locker.unlock();\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void dec() {\n",
    "        locker.lock();\n",
    "        super.dec();\n",
    "        locker.unlock();\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wyniki\n",
    "\n",
    "## Race condition (p. 1-2)\n",
    "\n",
    "Zgodnie z poleceniem, **program** musi zostać uruchomiony `100` razy. W celu ułatwienia, korzystam z narzędzia `gradle`\n",
    "i prostego `bash` skryptu, który pobiera wyniki wykonania programu:\n",
    "\n",
    "```bash\n",
    "for _ in {1..100}\n",
    "do\n",
    "    ./gradlew run | sed -n 's/^.*stan=\\s*\\(\\S*\\).*$/\\1/p'\n",
    "done\n",
    "```\n",
    "\n",
    "Pobrane wyniki zostały zapisane do pliku a następnie wczytane i przetwarzone przez skrypt w języku `python`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       0\n",
      "0  -1562\n",
      "1    708\n",
      "2     89\n",
      "3   1055\n",
      "4      7\n",
      "..   ...\n",
      "95 -2866\n",
      "96  -233\n",
      "97   417\n",
      "98 -1410\n",
      "99 -1203\n",
      "\n",
      "[100 rows x 1 columns]\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(\"output.txt\", header=None) \n",
    "\n",
    "print(df) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<Axes: title={'center': '0'}>]], dtype=object)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.hist(bins=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak widać z tego histogramu, wyniki zagęszczają się bliżej wartości `0`, ale są również wyniki położone dość\n",
    "daleko wartości `0`, np.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    4535\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.abs().max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synchronizacja wątków (p. 3)\n",
    "\n",
    "W przypadku zsynchronizowanych wątków, zgodnie z oczekiwaniami na wyjściu za każdym razem dostajemy `0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    0\n",
      "0   0\n",
      "1   0\n",
      "2   0\n",
      "3   0\n",
      "4   0\n",
      ".. ..\n",
      "95  0\n",
      "96  0\n",
      "97  0\n",
      "98  0\n",
      "99  0\n",
      "\n",
      "[100 rows x 1 columns]\n"
     ]
    }
   ],
   "source": [
    "df_sync = pd.read_csv(\"output_sync.txt\", header=None)\n",
    "print(df_sync)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    0\n",
       "0   0\n",
       "1   0\n",
       "2   0\n",
       "3   0\n",
       "4   0\n",
       ".. ..\n",
       "95  0\n",
       "96  0\n",
       "97  0\n",
       "98  0\n",
       "99  0\n",
       "\n",
       "[100 rows x 1 columns]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sync[df_sync == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak widać z powyższego wyniku, wszystkie `100` wartości są równe `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wnioski\n",
    "\n",
    "- **Race condition** czyli **Wyścig**, charakteryzuje się niedeterministycznym zachowaniem programu,\n",
    "  może powodować błędy trudne do wykrycia i pojawia się wtedy, gdy więcej niż jeden wątek\n",
    "  korzysta jednocześnie z zasobu dzielonego, przy czym co najmniej jeden próbuje go zmienić;\n",
    "\n",
    "- Język `Java` posiada własne mechanizmy synchronizacji, między innymi: semafory (`Semaphore`), lockery\n",
    "  (np. `ReentrantLock`), zmienne atomowe (atomics, np. `AtomicInteger`), słowo kluczowe `synchronized`;\n",
    "\n",
    "- Stosując modyfikator `volatile`, wszystkie zmiany dokonane na tych zmiennych będą przekazywane do\n",
    "  innych wątków;\n",
    "\n",
    "- Niezsynchronizowany dostęp do licznika powoduje wyścigi, w związku z czym nie otrzymujemy na wyjściu\n",
    "  oczekiwanej wartości, tzn. `0`;\n",
    "\n",
    "- Zsynchronizowany dostęp do licznika nie powoduje żadnych race condition i na wyjściu za każdym razem\n",
    "  wypisuje się wartość oczekiwana, czyli `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bibliografia\n",
    "\n",
    "1. [Materiały do laboratorium](https://home.agh.edu.pl/~funika/tw/lab1/)\n",
    "2. [The Java™ Tutorials - Synchronization](https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html)\n",
    "3. [Java Docs - Semaphore](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Semaphore.html)\n",
    "4. [Java Docs - ReentrantLock](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantLock.html)\n",
    "5. [Java Docs - AtomicInteger](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html)\n",
    "6. [Java Docs - Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html)\n",
    "7. [Baeldung - Guide to the Volatile Keyword in Java](https://www.baeldung.com/java-volatile)\n",
    "8. [Wikipedia - Race condition](https://en.wikipedia.org/wiki/Race_condition)\n",
    "9. [Wikipedia - Busy waiting](https://en.wikipedia.org/wiki/Busy_waiting)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}