9. Współbieżna Java: synchronizacja i koordynacja

Zajmiemy się teraz nowymi - dostarczanymi przez pakiet java.util.concurrent - machanizmami synchronizacji i koordynacji watków.  Znacznie poszerzają one możliwości współbieżnego programowania. Wprowadzają też kilka istotnych ułatwień.

1. Przypomnienie: synchronizacja i koordynacja działania wątków

class Balance {

 private int number = 0;

 public int balance() {
   number++;
   number--;
   return number;
 }

}

class BalanceThread extends Thread {

 private Balance b; // referencja do obiektu klasy Balance
 private int count; // liczba powtórzeń pętli w metodzie run

 public BalanceThread(String name, Balance b, int count) {
   super(name);
   this.b = b;
   this.count = count;
   start();
 }

 public void run() {
   int wynik = 0;
   // W pętli wielokrotnie wywołujemy metodę balance()
   // na rzecz obiektu b klasy Balance.
   // Jeżeli wynik metody jest różny od zera - przerywamy działanie pętli
   for (int i = 0; i < count; i++) {
     wynik = b.balance();
     if (wynik != 0) break;
   }
   // Pokazujemy wartość zmiennej wynik na wyjściu z metody run()
   System.out.println(Thread.currentThread().getName() + " konczy z wynikiem " + wynik);
 }
}

class BalanceTest {

 public static void main(String[] args) {

   int tnum = Integer.parseInt(args[0]); // liczba wątków
   int count = Integer.parseInt(args[1]); // liczba powtórzeń pętli w run()

   // Tworzymy obiekt klasy balance
   Balance b = new Balance();

   // Tworzymy i uruchamiamy wątki
   Thread[] thread = new Thread[tnum]; // tablica wątków
   for (int i = 0; i < tnum; i++)
      thread[i] = new BalanceThread("W"+(i+1), b, count);

   // czekaj na zakończenie wszystkich wątków
   try {
     for (int i = 0; i < tnum; i++) thread[i].join();
   } catch (InterruptedException exc) {
       System.exit(1);
   }
   System.out.println("Koniec programu");
 }

}

• Punkt a - wątek W1, po zwiększeniu zmiennej number zostaje wywłaszczony. Zaczyna działanie wątek W2
• Punkt b - wątek W2 po zwiększeniu zmiennej number zostaje wywłaszony. Pracę kontunuuje wątek W1 (mając za wartość zmiennej number 2)
• Punkt c - po zakończeniu wątku W1 (który zmniejszył number i zwrócił 1), wątek W2 kontunnuje pracę: zmniejsza number i zwraca wynik 0.

• zajmowanie zasobu (obiektu) przez wątek,
• wzajemne wykluczanie wątków w dostępie do zasobu (obiektu).

2. Przypomnienie: koordynacja wątków

• wait
• notify
• notifyAll

• Wątek wywołuje metodę wait na rzecz danego obiektu, gdy oczekuje, że ma się coś (zwykle w kontekście tego obiektu) zdarzyć (zwykle jest to pewna oczekiwana zmiana stanu obiektu, której ma dokonać inny wątek i która jest realizowana np. przez zmianę wartości jakiejś zmiennej - pola obiektu).
• Wywołanie  wait blokuje wątek (jest on odsuwany od procesora), a jednocześnie powoduje otwarcie rygla zajętego przez niego obiektu, umożliwiające dostęp do obiektu z innych wątków (wait może być wywołane tylko z sekcji krytycznej, bowiem  chodzi tu o współdziałanie wątków na tym samym ryglowanym obiekcie, a zatem konieczna jest synchronizacja). Inny wątek może teraz zmienić stan obiektu i powiadomić o tym wątek czekający (za pomocą metody notify lub notifyAll).
• Odblokowanie (przywrócenie gotowości działania i ew. wznowienie działania wątku) następuje, gdy inny wątek wywoła metodę notify lub notifyAll na rzecz tego samego obiektu, "na którym" dany wątek czeka (na rzecz którego wywołał metodę wait). 
• Wywołanie notify() odblokowuje jeden z czekających wątków, przy czym może to być dowolny z nich,
• Metoda notifyAll odblokowuje wszystkie czekające na danym obiekcie wątki,
• Wywołanie notify lub notifyAll musi być także zawarte w sekcji krytycznej.
  

class X {

   int n;
   boolean ready = false;
   ....
   synchronized  int  get() {
       try {
         while(!ready)
           wait();
       } catch (InterruptedException exc) { .. }
       ready = false;
       return n;
   }

   synchronized void put(int i) {
        n = i;
        ready = true;
        notify();
   }

}

// Klasa dla ustalania i pobierania tekstów
class Teksty {

  String txt = null;
  boolean newTxt = false;

  // Metoda ustalająca tekst - wywołuje Autor
  synchronized void setTextToWrite(String s) {
    while (newTxt == true) {
      try {
        wait();
      } catch(InterruptedException exc) {}
    }
    txt = s;
    newTxt = true;
    notifyAll();
  }

  // Metoda pobrania tekstu - wywołuje Writer
  synchronized String getTextToWrite() {
    while (newTxt == false) {
      try {
        wait();
      } catch(InterruptedException exc) {}
    }
    newTxt = false;
    notifyAll();
    return txt;
  }

}

// Klasa "wypisywacza"
class Writer extends Thread {

  Teksty txtArea;

  Writer(Teksty t) {
    txtArea=t;
  }

  public void run() {
    String txt = txtArea.getTextToWrite();
    while(txt != null) {
      System.out.println("-> " + txt);
      txt = txtArea.getTextToWrite();
      }
  }

}

// Klasa autora
class Author extends Thread {

  Teksty txtArea;

  Author(Teksty t)  {
    txtArea=t;
  }

  public void run() {

    String[] s = { "Pies", "Kot", "Zebra", "Lew", "Owca", "Słoń", null };
    for (int i=0; i<s.length; i++) {
      try { // autor zastanawia się chwilę co napisać
        sleep((int)(Math.random() * 1000));
      } catch(InterruptedException exc) { }
      txtArea.setTextToWrite(s[i]);
    }
  }

}

// Klasa testująca
public class Koord {

   public static void main(String[] args) {
     Teksty t = new Teksty();
     Thread t1 = new Author(t);
     Thread t2 = new Writer(t);
     t1.start();
     t2.start();
   }

}

3. Rygle jako obiekty typu Lock

• ReentrantLock - odpowiada znanemu nam mechanizmowi synchronizacji za pomocą słowa kluczowego synchronized
• ReentrantReadWriteLock - realizuje koncepcję tzw. read/write locks, pozwalającą na współdzielenie zasobu bez blokowania przy operacjach czytania i jednocześnie zapewnienie, aby operacje modyfikacji były zsynchronizowane z odczytem (natychmiastowo widoczne dla wątków czytających).

• są bardziej efektywne od synchronized w sytuacji dużej konkurencji wątków o zasoby,
• jako "zwykłe" obiekty Javy mogą być dostępne przez referencje w wielu miejscach kodu (np. przekazywane jako argumenty konstruktorów czy metod),
• mogą być zamykane i zwalniane w różnych strukturalnie sekcjach kodu np. w różnych metodach (ale wykonywanych przez ten sam wątek), synchronized może być użyte tylko w ramach tego samego bloku,
• możliwe jest sprawdzenie, czy rygiel jest zamknięty (inny wątek wykonuje sekcję krytyczną) i np. wtedy zajęcie się innymi czynnościami, a nie blokowanie bieżącego wątku na ryglu, mamy tu możliwości zastosowania metody tryLock() lub bezpośrednie odpytywanie obiektu-rygla czy jest zamknięty,
• możliwe jest oczekiwanie na uzyskanie dostępu do sekcji krytycznej (otwarcie rygla przez inny wątek) przez określony czas (nie chcemy blokować bieżącego wątku zbyt długo), służy do tego metoda tryLock(...) z podanym czasem oczekiwania,
• możliwe jest przerwanie wątku zablokowanego na jakimś ryglu, tu używamy metody lockInterruptibly() (synchronized nie daje tej możliwości).

Lock lock = new ReentrantLock();  // utworzenie rygla
// ....
// KOD WYKONYWANY WSPÓŁBIEŻNIE
lock.lock();                      // zamknięcie rygla (1)
// ... kod sekcji krytycznej
lock.unlock();                    // zwolnienie rygla (2)

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

class StringTab {

  private String[] txt;
  private Lock lock = new ReentrantLock();


  public StringTab(String[] txt) {
    this.txt = txt;
  }

  public void set(int i, String s) {
    lock.lock();
    txt[i] = s;
    lock.unlock();
  }

  public String get(int i) {
    String t = null;
    lock.lock();
    t = txt[i];
    lock.unlock();
    return t;
  }

}


public class Test1 {
  public static void main(String[] args) {

    final StringTab st = new StringTab(new String[] { "ala", "kot", "pies" });
    new Thread( new Runnable() {
      public void run() {
        st.set(3, "tygrys");
      }
    }). start();

    new Thread( new Runnable() {
      public void run() {
        try {
          TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("Minęły 2 sek. - Wątek 2 działa");
        System.out.println(st.get(0));
        System.out.println("Wątek 2 się kończy");
      }
    }). start();
  }
}

 public void set(int i, String s) {
    lock.lock();
    try {
      txt[i] = s;
    } catch (ArrayIndexOutOfBoundsException exc) {}
    lock.unlock();
  }

4. Konieczność użycia klauzuli finally. Klasa ReentrantLock.

  public void set(int i, String s) {
    lock.lock();
    try {
      txt[i] = s;
     } finally {
       lock.unlock();
     }
  }

Lock lock = new ReentrantLock();

public typ metoda() {
  typ zmienna;
  lock();
  // ...
  unlock();
  return zmienna;
}  

Object mutex = new Object();

public typ metoda() {
  typ zmienna;
  synchronized(mutex) {
    // ...
    return zmienna;
  }
}  

class Balance {

  private int number = 0;
  private Lock lock = new ReentrantLock();

  public int balance() {
    lock.lock();
    number++;
    System.out.print("*");
    number--;
    lock.unlock();
    return number;
  }

}

class BalanceThread extends Thread {

  private Balance b;  // referencja do obiektu klasy Balance
  private int count;  // liczba powtórzeń pętli w metodzie run

  public BalanceThread(String name, Balance b, int count) {
    super(name);
    this.b = b;
    this.count = count;
    start();
  }

  public void run() {
    int wynik = 0;
      for (int i = 0; i < count; i++) {
        wynik = b.balance();
        if (wynik != 0) break;
      }

    System.out.println("\n"+ Thread.currentThread().getName() +
                       " konczy z wynikiem  " + wynik);
  }
}

class BalanceTest {

  public static void main(String[] args) {

    int tnum = Integer.parseInt(args[0]);     // liczba wątków
    int count = Integer.parseInt(args[1]);    // liczba powtórzeń pętli w run()

    // Tworzymy obiekt klasy balance
    Balance b = new Balance();

    // Tworzymy i uruchamiamy wątki
    Thread[] thread = new Thread[tnum];

    long start = System.nanoTime();

    for (int i = 0; i < tnum; i++)
      thread[i] = new BalanceThread("W"+(i+1), b, count);

    // czekaj na zako˝czenie wszystkich w?tkˇw
    try {
      for (int i = 0; i < tnum; i++) thread[i].join();
    } catch (InterruptedException exc) {
      System.exit(1);
    }

    System.out.println("Czas: " + (System.nanoTime() - start) );


  }


}       

  public int balance() {
    try {
      lock.lock();
      number++;
      System.out.print("*");
      number--;
      return number;
    } finally {
        lock.unlock();
    }
  }

  public String get(int i) {
    String t = null;
    lock.lock();
    t = txt[i];
    lock.unlock();
    return t;
  }

  public String get(int i) {
    lock.lock();
    try {
      return txt[i];
    } finally {
        lock.unlock();
    }
  }

• Po pierwsze, jeśli pojawi się wyjątek, który przerwie wykonanie bloku try, to po zwolnieniu rygla w klauzuli finally stan obiektu może być niespójny. Dlatego w finally zawsze nalezy dostarczyć odpowiednich operacji porządkujących.

• Po drugie, w przypadku, gdy stosujemy ryglowanie przerywalne (lockInterruptibly() lub tryLock(...) z podanym czasem), to po przerwaniu wątku (metodą interrupt())  rygiel jest otwierany i wątek już go "nie posiada";  jednak finally jest wykonywane i próba zwolnienia rygla w tym miejscu powoduje wyjątek IllegalMonitorStateException (próba zwolnienia nieposiadanego rygla).

 int w;
 int innaLiczba;
 // ....

 // Kod metody balance  
 lock.lock();
 try {

      number++;
      if (print) System.out.print("*");
      w = number/innaLiczba;
      number--;

      return number;
  } finally {
      lock.unlock();
  } 

 public void run() {
    int wynik = 0;
      for (int i = 0; i < count; i++) {
        boolean print;
        if (i%20 == 0) print = true;
        else print = false;
        try {
          wynik = b.balance(print);
        } catch(Exception exc) { }
        if (wynik != 0) break;
      }
    System.out.println("\n"+ Thread.currentThread().getName() +
                       " konczy z wynikiem  " + wynik);
    System.out.println("Stan b: " + b);
  }
}  

public int balance1() {
    lock.lock();
    boolean balanced = true;
    try {
      number++;
      balanced = false;
      w = number/innaLiczba;
      number--;
      balanced = true;
      return number;
    } finally {
        if (!balanced) number--;
        lock.unlock();
    }

  }

 Lock lock = new ReentrantLock();

  Runnable task1 = new Runnable() {
     public void run() {
       System.out.println("Task 1 begins");
       try {
         lock.tryLock(10, TimeUnit.SECONDS); // albo lock.lockInterruptibly();
         System.out.println("Task 1 entered");
       } catch(InterruptedException exc) {
           System.out.println("Task 1 interrupted");
       } finally {
           lock.unlock();
       }
       System.out.println("Task 1 stopped");
     }
  };

 Lock lock = new ReentrantLock();

  Runnable task1 = new Runnable() {
     public void run() {
       System.out.println("Task 1 begins");
       try {
         lock.tryLock(10, TimeUnit.SECONDS); // albo lock.lockInterruptibly();
         System.out.println("Task 1 entered");
       } catch(InterruptedException exc) {
           System.out.println("Task 1 interrupted");
       } finally {
           ReentrantLock l = (ReentrantLock) lock;
           if (l.isHeldByCurrentThread()) lock.unlock();
       }
       System.out.println("Task 1 stopped");
     }
  };

5. Idiomy ryglowania

Lock lock = new ReentrantLock();
....

lock.lock();
try {
   // ...
| finally {
   // ... zapewnienie spójności stanów obiektu
   lock.unlock();
}  

Lock lock = new ReentrantLock();
....
try {
  lock.lockInterruptibly();

   // ...
| catch(InterruptedException exc) {
   // ... przerwanie działania - zakończenie metody run
finally {
   // ... zapewnienie spójności stanów obiektu
   ReentrantLock l = (ReentrantLock) lock;
   if (l.isHeldByCurrentThread()) lock.unlock();
}  

6. Efektywność synchronizacji

class Balance {

  private int number = 0;
  private Lock lock = new ReentrantLock();


  private boolean useLock;   // której metody synchronizacji użyć?

  public Balance(boolean ul) {
    useLock = ul;
  }

  public int balance(boolean print) { // parametr print mówi czy wypisać gwiazdkę
    if (!useLock) return balanceSynchro(print);
    else return balanceLocked(print);
  }

  // Synchronizacja za pomocą bezposrednich rygli
  public int balanceLocked(boolean print) {
    try {
      lock.lock();
      number++;
      if (print) System.out.print("*");
      number--;
      return number;
    } finally {
        lock.unlock();
    }
  }

  // Użycie synchronized
  public synchronized int  balanceSynchro(boolean print) {
    number++;
    if (print) System.out.print("*");
    number--;
    return number;
  }


}

class BalanceThread extends Thread {

  private Balance b;  // referencja do obiektu klasy Balance
  private int count;  // liczba pwotórzeń pętli w metodzie run

  public BalanceThread(String name, Balance b, int count) {
    super(name);
    this.b = b;
    this.count = count;
    start();
  }

  public void run() {
    int wynik = 0;
      for (int i = 0; i < count; i++) {
        boolean print;
        if (i%20 == 0) print = true;  // gwiazdkę będziemy drukować co 20 iterację
        else print = false;
        wynik = b.balance(print);
        if (wynik != 0) break;
      }


    System.out.println("\n"+ Thread.currentThread().getName() +
                       " konczy z wynikiem  " + wynik);
  }
}

class BalanceTest {

  static ArrayList<String> czasy = new ArrayList<String>(); // wyniki czasowe

  public static void test(int tnum, boolean lock) {

    // jesli lock jest true będziemy używać bezp. rygli
    Balance b = new Balance(lock);
    String wynik = lock ? "Lock " : "Synchro ";
    String id = lock ? "L" : "S";
    wynik += tnum;
    // Tworzymy i uruchamiamy wątki
    Thread[] thread = new Thread[tnum];

    long start = System.currentTimeMillis();

    for (int i = 0; i < tnum; i++)
      thread[i] = new BalanceThread(id +(i+1), b, 100);

    // czekaj na zakończenie wszystkich wątków
    try {
      for (int i = 0; i < tnum; i++) thread[i].join();
    } catch (InterruptedException exc) {
      System.exit(1);
    }
    wynik += " Czas: " + (System.currentTimeMillis() - start);
    System.out.println(wynik);
    czasy.add(wynik);
    // Uduwamy niepotrzebne obiekty-wątki
    for (int i = 0; i < thread.length; i++) { thread[i] = null; }
    System.gc();
  }

  public static void main(String[] args) {
    //Test synchro
    for (int i=100; i<=1000; i+=100) {
      test(i, false);
    }
    // Test Lock
    for (int i=100; i<=1000; i+=100) {
      test(i, true);
    }
    for (String msg : czasy) { System.out.println(msg);

    }

  }


} 

• użycie synchronized przy braku silnej konkurencji wątków jest w Javie 1.6 bardziej efektywne,
• w Javie 1.6 wewnętrzne mechanizmy synchronizacji zostały zmodyfikowane, tak aby synchronized było bardziej efektywne przy dużej konkurencji wątków, jednocześnie mechanizm bezpośrednich rygli poprawiono pod względem efektywności przy braku silnej konkurencji.

7. Lock czy synchronized?

• chcemy mieć przerywalne blokady,
• piszemy bardziej wysublimowane programy, w których np. nie chcemy blokować wątku, jesli ktoś inny zajął rygiel:
  

Lock lock;

boolean got = lock.tryLock();
if (got) {
   try {
     // sekcja krytyczna
   } finally {
       lock.unlock();
   }  
} else {
    robimy coś innego - może staramy się np. przetwarzać inny zasób
}

• chcemy lub musimy inaczej strukturyzować kod (zwalniać rygle w innych blokach niż są zajmowane)

  // Obsługa zleceń
  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {

    resp.setContentType("text/html");

    // Wywolanie serwletu pobierania parametrów
    RequestDispatcher disp = context.getRequestDispatcher(getParamsServ);
    disp.include(req,resp);

    // Pobranie bieżącej sesji
    // i z jej atrybutów - wartości parametrów
    // ustalonych przez servlet pobierania parametrów
    // Różne informacje o aplikacji (np. nazwy parametrów)
    // są wygodnie dostępne poprzez własną klasę BundleInfo

    HttpSession ses = req.getSession();

    String[] pnames = BundleInfo.getCommandParamNames();
    for (int i=0; i<pnames.length; i++) {

      String pval = (String) ses.getAttribute("param_"+pnames[i]);

      if (pval == null) return;  // jeszcze nie ma parametrów

      // Ustalenie tych parametrów dla Command
      command.setParameter(pnames[i], pval);
    }

    // Wykonanie działań definiowanych przez Command
    // i pobranie wyników
    // Ponieważ do serwletu może naraz odwoływać sie wielu klientów
    // (wiele watków) - potrzebna jest synchronizacja

    Lock mainLock = new ReentrantLock();

    mainLock.lock();
      // wykonanie
      command.execute();

      // pobranie wyników
      List results = (List) command.getResults();

      // Pobranie i zapamiętanie kodu wyniku (dla servletu prezentacji)
      ses.setAttribute("StatusCode", new Integer(command.getStatusCode()));

      // Wyniki - będą dostępne jako atrybut sesji
      ses.setAttribute("Results", results);
      ses.setAttribute("Lock", mainLock);


    // Wywołanie serwletu prezentacji
    disp = context.getRequestDispatcher(presentationServ);
    disp.forward(req, resp);
  }

public class ResultPresent extends HttpServlet {


  public void serviceRequest(HttpServletRequest req,
                             HttpServletResponse resp)
                             throws ServletException, IOException
  {
    ServletContext context = getServletContext();

    // Włączenie strony generowanej przez serwlet pobierania parametrów
    // (formularz)
    String getParamsServ = context.getInitParameter("getParamsServ");
    RequestDispatcher disp = context.getRequestDispatcher(getParamsServ);
    disp.include(req,resp);

    // Uzyskanie wyników i wyprowadzenie ich
    // Controller po wykonaniu Command zapisał w atrybutach sesji
    // - referencje do listy wyników jako atrybut "Results"
    // - wartośc kodu wyniku wykonania jako atrybut "StatusCode"

    HttpSession ses = req.getSession();
    Lock mainLock = (Lock) ses.getAttribute("Lock");

    List results = (List) ses.getAttribute("Results");
    Integer code = (Integer) ses.getAttribute("StatusCode");

    mainLock.unlock();  // otwarcie rygla


    PrintWriter out = resp.getWriter();
    out.println("<hr>");

    // Uzyskanie napisu właściwego dla danego "statusCode"
    String msg = BundleInfo.getStatusMsg()[code.intValue()];
    out.println("<h2>" + msg + " aha!" + "</h2>");

    // Elementy danych wyjściowych (wyników) mogą być
    // poprzedzane jakimiś opisami (zdefiniowanymi w ResourceBundle)
    String[] dopiski = BundleInfo.getResultDescr();

    // Generujemy raport z wyników
    out.println("<ul>");
    for (Iterator iter = results.iterator(); iter.hasNext(); ) {
      out.println("<li>");

      int dlen = dopiski.length;  // długość tablicy dopisków
      Object res = iter.next();
      if (res.getClass().isArray()) {  // jezeli element wyniku jest tablicą
        Object[] res1 = (Object[]) res;
        int i;
        for (i=0; i < res1.length; i++) {
          String dopisek = (i < dlen ? dopiski[i] + " " : "");
          out.print(dopisek + res1[i] + " ");
        }
        if (dlen > res1.length) out.println(dopiski[i]);
      }
      else {                                      // może nie być tablicą
        if (dlen > 0) out.print(dopiski[0] + " ");
        out.print(res);
        if (dlen > 1) out.println(" " + dopiski[1]);
      }
      out.println("</li>");
    }
    out.println("</ul>");
  }
//..
}

8.  Dodatkowe możliwości rygli

9. Warunki

• Condition jest obiektem i można z nim robić to co z innymi obiektami (np. przekazywać)
• oczywiście jest związany z danym ryglem ale dla każdego rygla może być wiele warunków.

import java.util.concurrent.locks.*;

class Teksty {

  Lock lock = new ReentrantLock();
  Condition txtWritten = lock.newCondition();
  Condition txtSupplied = lock.newCondition();

  String txt = null;
  boolean newTxt = false;

  // Metoda ustalająca tekst - wywołuje Autor
  void setTextToWrite(String s) {
    lock.lock();
    try {
      if (txt != null) {
        while (newTxt == true)
          txtWritten.await();
      }
      txt = s;
      newTxt = true;
      txtSupplied.signal();
    } catch (InterruptedException exc) {
    } finally {
         lock.unlock();
    }
  }


  // Metoda pobrania tekstu - wywołuje Writer
   String getTextToWrite() {
     lock.lock();
     try {
       while (newTxt == false)
         txtSupplied.await(); // może być Interrupted
       newTxt = false;
       txtWritten.signal();
       return txt;
     } catch (InterruptedException exc) {
         return null;
     } finally {
         lock.unlock();
     }
   }


}

// Klasa "wypisywacza"
class Writer extends Thread {

  Teksty txtArea;

  Writer(Teksty t) {
    txtArea=t;
  }

  public void run() {
    String txt = txtArea.getTextToWrite();
    while(txt != null) {
      System.out.println("-> " + txt);
      txt = txtArea.getTextToWrite();
      }
  }

}

// Klasa autora
class Author extends Thread {

  Teksty txtArea;

  Author(Teksty t)  {
    txtArea=t;
  }

  public void run() {

    String[] s = { "Pies", "Kot", "Zebra", "Lew", "Owca", "Słoń", null };
    for (int i=0; i<s.length; i++) {
      try { // autor zastanawia się chwilę co napisać
        sleep((int)(Math.random() * 1000));
      } catch(InterruptedException exc) { }
      txtArea.setTextToWrite(s[i]);
    }
  }

}

// Klasa testująca
public class Koord {

   public static void main(String[] args) {
     Teksty t = new Teksty();
     Thread t1 = new Author(t);
     Thread t2 = new Writer(t);
     t1.start();
     try { Thread.sleep(3000); } catch(Exception exc) {}
     t2.start();
   }

}

10. Synchronizatory wyższego poziomu, blokujące kolejki, konkurencyjne kolekcje i atomiki.

• Semafory (Semaphore),
• Bariery (CyclicBarrier),
• Zasuwy (CountDownLatch),
• Wymienniki (Exchanger).

• ArrayBlockingQueue
• LinkedBlockingQueue

• ConcurrentHashMap
• ConcurrentLinkedQueue

11. Podsumowanie

• zaletamu bezpośrednich rygli typu Lock,
• sposobami programowania przy ich użyciu,
• warunkami (obiektami klasy Condition) i ich użyciem.

12. Zadania

Mamy n zasobów, które są modyfikowane przez m wątków. Modyfikacje trochę trwają (użyć sleep).
Sprawdzić czy wątek odczytujący dane z zasobów będzie działał bardziej efektywnie, jeśli zastosować tryLock.

Zadanie 2