feat: serie3 ex 3/4 done

serie3/ex1.md

+# Exercice 1
+
+Soit le pseudo-code du programme _P_ multi-threadé suivant :
+
+```
+int x = 2;
+
+thread1 :
+    while (1) {
+    x = 1;
+    }
+
+thread2 :
+    while (1) {
+    x = 2;
+    }
+
+thread3 :
+    while (1) {
+    if (x == 2) exit(0);
+    }
+```
+
+## Question
+
+Est-il possible que _P_ ne se termine jamais ?
+
+## Réponse
+
+Dans le cas où le système sur lequel est exécuté ce code n'a pas d'ordonnancement
+spécifique en terme d'exécution des threads (ce qui peut être le cas sur certain
+microcontrôleurs) ce programme se **terminera toujours** car dans un des cas
+possible le thread 3 sera exécuté à la suite du thread 2 ce qui entraînera la 
+condition de sortie du programme ou plus simplement que le premier thread qui
+s'exécutera sera directement le thread 3 ce qui terminera aussi le programme.
+
+

serie3/ex2.md

+# Exercice 2
+
+Soit le pseudo-code du programme _P_ multi-threadé suivant :
+
+```
+int y = z = 0;
+
+thread1 :
+    x = y + z;
+
+thread2 :
+    y = 1;
+    z = 2
+```
+
+## Question
+
+Une fois _P_ terminé, est-il possible que la valeur de la variable `x` soit égale
+à 2 ?
+
+
+## Réponse
+
+Non, cela n'est pas possible car même si le changement de contexte se passe à
+la moitié de l'exécution du thread 2, la valeur de $y$ sera uniquement modifiée et
+pas celle de $z$ ce qui entraînera le calcul suivant :
+
+$$
+\begin{aligned}
+x &= y + z \\
+&= 1 + 0 \\
+&= 0
+\end{aligned}
+$$
+
+Dans tous les autres cas de figures, le résultat du calcul sera $x = 0$ ou
+$x = 3$ (dans le cas ou le thread 2 s'exécute dans son entièreté.

serie3/ex3.md

+# Exercice 3
+
+Soit la boucle suivante :
+
+```c
+for (int i = -10; i < 10; i++) {
+    x++;
+}
+```
+
+## Question
+
+Sur une machine _monoprocesseur_, quelles sont les valeurs extrêmes $[\text{min},
+\text{max}]$ du domaine de valeurs possibles qu'est susceptible de prendre la
+variable **partagée** `x`, initialisée à 0, après exécution complète du code
+ci-dessus par 2 threads distincts ?
+
+
+## Réponse
+
+Premièrement, il faut prendre en compte le nombre d'itérations de cette boucle
+`for` qui est égale à :
+
+$$
+\begin{aligned}
+\text{N} &= \lvert -10 \rvert + 10 \\
+&= 10 + 10 \\
+&= 20 \\
+\end{aligned}
+$$
+
+Par la suite, compte tenu que ce code est exécuté sur une machine monoprocesseur,
+cela signifie que les 2 threads en question s'exécuteront forcément de manirềre
+séquentielle.
+
+Par conséquent le thread 1 s'exécutera est incrémentera la variable `x` jusqu'à
+la valeur de 20, puis s'exécutera le second thread qui incrémentera la valeur
+jusqu'à 40. 
+
+Donc l'intervalle des valeurs de `x` est :
+
+$$
+x \in [0, 40]
+$$