\chapter{threads}
\index{threads}

% ----------------------------------------------------------------

Ahemmm, par quoi commencer\footnote{Par de l'aspirine ?} ?
La programmation avec les fils d'exécution est un espace
rempli de chausse-trappes. 
Par un
extrait de la page \texttt{pthreads(6)} ? Voilà, ça c'est bien :

\begin{quote}
POSIX.1 specifies a set of interfaces (functions, header files) for
threaded programming commonly known as Pthreads.
A single process can contain multiple threads, all of which are
executing the same program.  These threads share the same global
memory (data and heap segments), but each thread has its own stack
(automatic variables).
\end{quote}

Et c'est là que les ennuis potentiels débarquent : 
\textit{share the same global memory}, ce qui veut dire en gros
«~se partagent la même mémoire globale~». Et en français de tous
les jours, «~ils vont se marcher sur les pieds~».

D'un autre coté, ce paradigme permet de faire des choses assez
choupi, comme un synthétiseur d'évènement.

% ----------------------------------------------------------------
\section{Un exemple}

Nous allons partir sur un exemple peu réaliste, mais simple
à comprendre. Nous aurons un seul fil d'exécution qui affichera
un compteur, puis l'incrémentera. Pendant ce temps, la branche
principale du programme mettra du random dans le compteur, en
espérant perturber l'autre branche.

\lstinputlisting[language=c]{code/thread-demo.c}

Voilà, nous avons là deux \textsl{race conditions} qui
peuvent avoir des effets pervers~: Ils vont
effectivement se marcher sur les pieds.

Dans le thread
(la fonction \texttt{fil}), le
compteur est incrémenté, \textbf{puis} il est affiché. 
Si la branche principale poke du random dans le compteur
entre ces deux opérations, *paf* le chien. 
Et réciproquement, si le \texttt{main} pose son aléa dans
le compteur, \textbf{puis} l'affiche, cet aléa peut avoir
été incrémenté par l'autre partie du processus.

Un esprit pervers vient quand même modérer ces affirmations
en prétendant que dans ces deux cas, les \textsl{race conditions}
pourraient dépendre des optimisations du compilateur,
et de l'utilisation du \texttt{volatil} pour notre compteur.

%
% ----------------------------------------------------------------

\section{ITC}
\index{ITC} 

\textit{Inter Thread Communication}

Imaginons une application avec un thread qui fait le travail effectif
(nous le nommerons \textsl{worker}), et plusieurs autres threads
qui attendent des ordres de l'extérieur (telnet, MIDI\index{MIDI},
joystick\index{joystick}\dots) et qui doivent passer ces commandes
au \textsl{worker}.

Comment allons-nous procéder\footnote{Et c'est une vraie question !} ?

Une première piste : http://tools.ietf.org/html/rfc3117

Une seconde : \ref{chap:IPC}, page \pageref{chap:IPC}.

%  ----------------------------------------------------------------