\begin{slide}{Warteschlangen}

Wie synchronisiert Threads über einen Zeitraum,
der länger ist als ein Methoden-Aufruf?

In Java besitzt jedes Objekt eine Warteschlange (\emph{wait set}) von Threads.
\begin{itemize}\itemsep 0pt\parskip 1pt
\item \verb|ob.wait()| : der aktuelle Thread wartet (blockiert),
  d. h. wird in die Warteschlange von  \verb|ob| aufgenommen,
\item \verb|ob.notify()| : ein beliebiger der Threads
  aus der Warteschlange von \verb|ob| wird aufgeweckt.
\end{itemize}

für jede Methode muß man den Objekt-Lock besitzen:
\begin{itemize}\itemsep 0pt\parskip 1pt
\item \verb|wait()| gibt den Lock frei
\item der durch \verb|notify()| aufgeweckte Thread
  erhält den Lock zurück.
\end{itemize}

\end{slide}

\begin{slide}{Beispiel: Philosophen in der Mensa}

(Edsger Dijkstra, Tony Hoare, ca. 1965)
\begin{itemize}
\item Prozess $=$ Philosoph
\item gemeinsame Ressource $=$ Gabel
\end{itemize}

gewünschte System-Eigenschaften:
\begin{itemize}
\item liveness (kein Verklemmen)

  die Folge der Aktionen ist unendlich
\item
  fairness (kein Verhungern)

  falls ein Prozeß eine Ressource anfordert, 
  bekommt er sie nach endlich vielen Aktionen tatsächlich
\end{itemize}
\end{slide}

\begin{slide}{Modellierung des Ressourcenzugriffs}

Modellierung des ausschließlichen Ressourcenzugriffs:
\begin{verbatim}
class Fork { 
    private boolean taken = false;
    synchronized void take () {
        while (taken) { wait (); }  
        taken = true;               }
    synchronized void drop () {
        taken = false; notify ();   } }
\end{verbatim}

beachte:
\begin{itemize}
\item beide Methoden sind \verb|synchronized|
\item \verb|wait()| innerhalb einer Schleife,
  die die Bedingung testet (nach Aufwachen)
\end{itemize}

\end{slide}
