Wprowadzenie do programowania współbieżnego

Współbieżność oznacza równoległe wykonywanie różnych zadań. W ramach jednego programu efekt ten osiągany jest poprzez tworzenie i uruchamianie tzw. wątków. Poznamy zatem  istotę programowania wielowątkowego w Javie, sposoby tworzenia, uruchamiania, wstrzymywania i kończenia wątków oraz zagadnienia związane z synchronizacją wątków oraz ich koordynacją. Tematy te będą przedstawione na podstawowym, elementarnym poziomie. 

1. Podstawowe pojęcia: procesy i wątki

• współpracy (cooperative multistasking) - wątek sam decyduje, kiedy oddać czas procesora innym wątkom,
• wywłaszczania (pre-emptive multistasking) - o dostępie wątków do procesora decyduje systemowy zarządca wątków: przydziela on wątkowi kwant czasu procesora, po upłynięciu którego odsuwa wątek od procesora i przydziela kwant czasu procesora innemu wątkowi.

2. Jak stworzyć i uruchomić nowy wątek?

public class Timer extends Thread {

   public void run() {
     int time = 0;
     while (true) {
       try {
         this.sleep(1000);
       } catch(InterruptedException exc) {
           System.out.println("Wątek zliczania czasu zoostał przerwany.");
           return;
       }
       time++;
       int minutes = time/60;
       int sec = time%60;
       System.out.println(minutes + ":" + sec);
     }
   }
}

import javax.swing.*;

public class Quiz {

  // Stolice do odgadnięcia
  private final String[] CAP = {"Praga", "Bratysława", "Moskwa",
                                "Berlin", "Kijów", "Wilno", "Mińsk" };

  // Czy stolica była już podana ?
  private boolean[] entered = new boolean[CAP.length];

  public Quiz() {

    int n = CAP.length;

    JOptionPane.showMessageDialog(null, "Podaj stolice lądowych sąsiadów Polski");
    String askMsg = "Wpisz kolejną stolicę:" ;

    int count = 0;  // ile podano prawidłowych odpowiedzi

    // Uruchomienie wątku zliczającego i pokazującego upływający czas
    Timer tm = new Timer();
    tm.start();

    while (count < CAP.length) { // dopóki nie podano wszystkich stolic
      String input = JOptionPane.showInputDialog("Odpowiedzi: " + count + '/' + n +
                                                  '\n' + askMsg);
      if (input == null) break;
      if (isOk(input)) count++;  // jeżeli ta odpowiedź prawidłowa
    }
    System.exit(0);
  }

  // Czy odpowiedź jest prawidłowa i czy jej wcześniej nie podano?

  private boolean isOk(String s) {
    for (int i=0; i < CAP.length; i++) {
      if (s.equalsIgnoreCase(CAP[i]) && !entered[i])
         return (entered[i] = true);
    }
    return false;
  }

  public static void main(String args[]) {
    new Quiz();
  }
}

import javax.swing.*;

public class Quiz1a extends Thread {

  private final String[] CAP = {"Praga", "Bratysława", "Moskwa",
                                "Berlin", "Kijów", "Wilno", "Mińsk" };

  private boolean[] entered = new boolean[CAP.length];

  private int time = 0; // licznik czasu

  public Quiz1a() {
    int n = CAP.length;

    JOptionPane.showMessageDialog(null, "Podaj stolice sąsiadujących krajów");
    String askMsg = "Wpisz kolejną stolicę:" ;
    int count = 0;

    // Uruchomienie wątku zliczania czasu
    start();

    while (count < CAP.length) {
      String input = JOptionPane.showInputDialog("Odpowiedzi: " + count + '/' + n +
                                                 ".   Czas: " + getTime() + '\n' +
                                                 askMsg);
      if (input == null) break;
      if (isOk(input)) count++;
    }
    JOptionPane.showMessageDialog(null, "Czas wpisywania: " + getTime());
    System.exit(0);
  }

  // Kod który wykonuje się w odrębnym wątku
  public void run() {
    while (true) {
      try {
        this.sleep(1000);
      } catch(InterruptedException exc) {
          System.out.println("Wątek zliczania czasu został przerwany.");
          return;
      }
      time++;
      System.out.println(getTime());
    }
  }

  // Metoda zwracająca bieżący czas w formie min : sek
  private String getTime() {
    int minutes = time/60;
    int sec = time%60;
    return minutes + ":" + sec;
  }

  private boolean isOk(String s) {
    for (int i=0; i < CAP.length; i++) {
      if (s.equalsIgnoreCase(CAP[i]) && !entered[i])
         return (entered[i] = true);
    }
    return false;
  }


  public static void main(String args[]) {
    new Quiz1a();
  }
}

class Timer implements Runnable {
  public void run() {
    int time = 0;
    while (true) {
      try {
        Thread.sleep(1000);
      } catch(InterruptedException exc) {
          System.out.println("Wątek zliczania czasu zoostał przerwany.");
          return;
      }
      time++;
      int minutes = time/60;
      int sec = time%60;
      System.out.println(minutes + ":" + sec);
    }
  }
}

    Timer timer = new Timer();
    Thread thread = new Thread(timer);
    thread.start();

new Thread(new Timer()).start();

• niekiedy daje lepsze możliwości separowania kodu  (kod odpowiedzialny za pracę wątku może być wyraźnie wyodrębniony w klasie implementującej Runnable).
• a w  niektórych okolicznościach  - mianowicie, gdy chcemy umieścić metodę run() w klasie, która dziedziczy jakąś inną klasę - jest jedynym możliwym sposobem.

public class Car extends Vehicle implements Runnable {

    private String nrRej;
    private int tankCapacity;   // pojemność baku
    private int fuel;           // ile jest paliwa?

    public Car(String nr, Person owner, int w, int h, int l,
               int weight, int tankCap)  {
        super(owner, w, h, l, weight);
        nrRej = nr;
        tankCapacity = tankCap;
    }

    // Napełnianie baku
    public void fill(int amount)  {
      fuel += amount;
      if (fuel > tankCapacity) fuel = tankCapacity;
    }

    // Start samochodu
    public void start()  {
      if (fuel > 0)   {
          super.start();
          new Thread(this).start();  // uruchamiamy wątek zużycia paliwa
      }
      else System.out.println("Brak paliwa");
    }

    // Zatrzymanie samochodu
    public void stop()  {
        super.stop();
    }

    // Kod, który wykonuje się w odrębnym wątku
    // co 1 sek. czasu programu zużywany jest 1 litr paliwa
    public void run()  {
      while(true) {
        try {
          Thread.sleep(1000);
        } catch(InterruptedException exc) { return; }
        fuel--;
        System.out.println("Paliwo: " + fuel);  // śledzimy ile jest paliwa
        if (fuel <= 0) break;    // jeżeli brak paliwa...
      }
     System.out.println("Zatrzymanie samochodu z powodu braku paliwa");
     stop();                     // zatrzymanie samochodu, bo brak paliwa
    }

    public String toString()  {
       return "Samochód nr rej " + nrRej + " - " + getState(getState());
    }
}

public class TestCar1 {

   // Symulacja upływu czasu...
   static void delay(int sek) {
     while(sek-- > 0) {
       try {
         Thread.sleep(1000);
       } catch (Exception exc)  { }
     }
    }

 public static void main(String[] args)  {
    Car c = new Car("WA1090", new Person("Janek", "0909090"),
                     100, 100, 100, 100, 50);

    c.fill(10);   // napełniamy bak
    c.start();    // ruszamy ...
    System.out.println(c + ""); // co się dzieje z samochodem
    delay(12);    // niech upłynie 12 sek. jazdy od tego momentu
    System.out.println(c + ""); // co się dzieje z samochodem
 }
}

    c.fill(10);   // napełniamy bak
    c.start();    // ruszamy ...
    System.out.println(c + ""); // co się dzieje z samochodem
    delay(3);     // niech upłyną 3 sek.
    c.stop();     // samochód się zatrzymuje...
    System.out.println(c + ""); // co się dzieje z samochodem
    delay(9);    // niech upłynie jeszcze 9 sek.  od tego momentu
    System.out.println(c + ""); // co się dzieje z samochodem

import javax.swing.*;

class AnonymousRunnable {
	
  public AnonymousRunnable() {

   Runnable runner = new Runnable() {
     public void run() {
       int time = 0;
       while (true) {
         try {
           Thread.sleep(1000);
         } catch(InterruptedException exc) { return; }
         System.out.println(time++/60 +  " min. " + time%60 + " sek.");
      }
     }
    };

    new Thread(runner).start();
    String s, out = "";
    while ((s = JOptionPane.showInputDialog("Wprowadź jakiś tekst:")) != null)
      out += " " + s;
    System.out.println(out);
    System.exit(0);
    }

  public static void main(String args[]) {
    new AnonymousRunnable();
  }
}

3. Kończenie pracy wątku

    public void run()  {
      while(getState() == MOVING) {
        try {
          Thread.sleep(1000);
        } catch(InterruptedException exc) { return; }
        fuel--;
        System.out.println("Paliwo: " + fuel);  // śledzimy ile jest paliwa
        if (fuel <= 0) stop();    // jeżeli brak paliwa...zatrzymujemy samochód
      }
    }

new Thread(this).start();

• konstruktor Thread(Runnable, String), który ma dodatkowy argument typu String, dzięki czemu każdemu wątkowi możemy nadać unikalną nazwę,
• statyczną metodę currentThread() z klasy Thread, która zwraca referencję do bieżącego wątku (tego, ktory wykonuje ten fragment kodu, w którym znajduje się wywołanie tej metody).
• metodę getName z klasy Thread, która zwraca nazwę watku (w szczególnoście tę nadaną za pomocą konstruktora).
  

class Car {
    ...

    int tnr = 1;  // numer wątku

    // Start samochodu
    public void start()  {
      if (fuel > 0)   {
          super.start();
          new Thread(this, "Nr " + tnr++).start();
      }
      else System.out.println("Brak paliwa");
    }

    ...

    public void run()  {

      Thread cThread = Thread.currentThread();

      while(getState() == MOVING ) {
        try {
          Thread.sleep(1000);
        } catch(InterruptedException exc) { return; }
        fuel--;
        System.out.println("Paliwo zużywa wątek: " + cThread.getName() +
                           ", pozostało paliwa: " + fuel);
        if (fuel <= 0) stop();
      }
    }

}

class Test {
  ....
  public static void main(String[] args)  {
    Car c = new Car(...);

    c.fill(10);
    c.start();
    c.start();
    c.start();
    delay(10);
    ...
  }
}

• wątek zużycia paliwa zakończy działanie,
• ten obiekt-wątek (który wlaśnie zakończył działanie) będzie usunięty z pamięci przez odśmiecacza,
• kolejne wywołanie metody start() wobec samochodu stworzy i uruchomi nowy wątek zużycia paliwa.

public class Car extends Vehicle implements Runnable {

    ...
    private Thread fuelConsumeThread;
    ...

    // Start samochodu
    public void start()  {
      if (fuel > 0)   {
          super.start();
          if (fuelConsumeThread == null) {
            fuelConsumeThread = new Thread(this);
            fuelConsumeThread.start();
          }
      }
      else System.out.println("Brak benzyny");
    }

    // Zatrzymanie samochodu
    public void stop()  {
        fuelConsumeThread = null;
        super.stop();
    }

    // Zużycie paliwa - wykonuje się jako wątek
    public void run()  {
      Thread cThread = Thread.currentThread();
      while(cThread == fuelConsumeThread ) {
        try {
          Thread.sleep(1000);
        } catch(InterruptedException exc) { return; }
        fuel--;
        System.out.println("Pozostało paliwa: " + fuel);
        if (fuel <= 0) stop();
      }
    }

   ....
}

4. Synchronizacja 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.

class Balance {

  private int number = 0;

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

}

• użycie klas niezmiennych (immutables), bowiem obiekty niezmienne (właśnie przez swą niezmienność) nie stwarzają problemu spójności stanów przy dostępie z wielu wątków,
• użycie kodów wielobieżnych (reentrant); kody wielobieżne są bezpieczne w użyciu wielowątkowym; przykładowo, kod który używa wyłącznie zmiennych lokalnych i nie odnosi się do pól  klasy jest wielobieżny i nie wymaga synchronizacji,
• czasami można użyć zmiennych ze specyfikatorem volatile (o którym była już mowa); generalnie dostęp do takich zmiennych nie musi być synchronizowany dla operacji atomistycznych (wykonywanych "w jednym takcie"), ale to czy dana operacja jest atomistyczna zależy od architektury systemowej i implementacji JVM.

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;
    synchronized(b) {
      for (int i = 0; i < count; i++) {
        wynik = b.balance();
        if (wynik != 0) break;
      }
    System.out.println(Thread.currentThread().getName() +
                       " konczy z wynikiem  " + wynik);
    }
  }
}

• nie będzie równocześnie działać na tym samym obiekcie,
• nie będzie równocześnie wykonywać tego samego kodu.

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

5. 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 ktorego 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();
   }

}

6. Stany wątków

• wywołania metody sleep (usypiającej wątek). Powrót do stanu Runnable - po upływie podanego czasu (uwaga: jeśli uśpiony wątek zajął jakiś obiekt, to rygiel nie jest zwalniany przy przesunięciu wątku do stanu NotRunnable, co może powodować blokowanie działania programu),
• albo wywołania metody wait, po którym następuje zwolnienie rygla. Powrót do stanu Runnable po tym jak inny wątek użyje na rzecz tego samego obiektu, na którym synchronizowany jest czekający wątek, metody notify lub notifyAll,
• albo blokowania na operacjach wejścia-wyjścia. Powrót do stanu Runnable: po zakończeniu operacji,
• albo blokowanie na obiekcie z zamkniętym ryglem.

7. Wstrzymywanie i przerywanie wątków

   while (warunek_działania_wątku) {
     try {
       synchronized(this) {
         while (suspended)  // warunek wstrzymania wątku
           wait();
       }
     } catch(InterruptedException exc) { return; }
     // ... praca wątku.
   }

• wait
• sleep
• join 

import javax.swing.*;

class SomeThread extends Thread {

  volatile boolean stopped = false;
  volatile boolean suspended = false;

  public void run() {

    double d = 0;
    while(!stopped) {
      try {
        synchronized(this) {
          while (suspended) wait();
        }
      } catch (InterruptedException exc) {
          System.out.println("Obsluga przerwania watku w stanie wait");
          System.out.println("Co powie isInterrupted() ?: "+ isInterrupted());
      }
      if (suspended) System.out.println("Watek wstrzymany na wartosci " + d);
      else System.out.println(++d);
    }
  }

  public void stopThread() {
    stopped = true;
  }

  public void suspendThread() {
    suspended = true;
  }

  public void resumeThread() {
    suspended = false;
    synchronized(this) {
      notify();
    }
  }

}

public class ActionsOnThread {
	
  public static void main(String args[]) {
    String msg = "I = interrupt\n" +
                 "E = end\n" +
                 "S = suspend\n" +
                 "R = resume\n" +
                 "N = new start";

    SomeThread t = new SomeThread();
    t.start();
    String cmd;
    while ((cmd = JOptionPane.showInputDialog(msg)) != null) {
      char c = cmd.charAt(0);
      switch (c) {
        case 'I' : t.interrupt(); break;
        case 'E' : t.stopThread(); break;
        case 'S' : t.suspendThread(); break;
        case 'R' : t.resumeThread(); break;
        case 'N' : if (t.isAlive())
                     JOptionPane.showMessageDialog(null, "Thread alive!!!");
                   else {
                     t = new SomeThread();
                     t.start();
                   }
                   break;
        default  : break;
      }
      JOptionPane.showMessageDialog(null,
                  "Command " + cmd + " executed.\n" +
                  "Thread alive  ? " + (t.isAlive() ? "Y\n" : "N\n") +
                  "Thread interrupted ? " + (t.isInterrupted() ? "Y\n" : "N")
                  );
    }
    System.exit(0);
  }
}

8. Priorytety wątków

• nie zwolni procesora na skutek uśpienia (metoda sleep), dobrowolnego oddania czasu (metoda yield()), lub innych przyczyn (o których mowa była przy omawianiu stanów wątków),
• wątek o wyższym priorytecie nie będzie gotowy do wykonania,
• nie upłynie przydzielony mu kwant czasu procesora (jeśli system operacyjny zapewnia wywłaszczanie po upływie kwantu czasu).

9. Demony i grupy

10. Zliczanie czasu i zadania czasowe

import java.util.*;

// Klasa definiująca zadanie do wykonania
// tu będzie to wypisywanie komunikatów

class Message extends TimerTask {

  private String msg;        // komunikat
  private boolean showDate;  // czy pokazać datę

  public Message(String s, boolean show) {
    msg = s;
    showDate = show;
  }

  // Ten kod będzie wykonywany przez Timer
  // według charakterystyk czasowych podanych w metodzie schedule
  public void run() {
    String msg1 = msg;
    if (showDate) msg1 = "Jest " + new Date() + '\n' + msg;
    System.out.println(msg1);
  }
}

// Test
public class Timer1 {

  public static void main(String[] args) {

    // Utworzenie zadań
    Message msgTask1 = new Message("Przypominam o podlaniu kwiatów!", true),
            msgTask2 = new Message("I zakończ ten program!", false);

    // Czas rozpoczęcia drugiegi zadania:
    // za trzy sekundy od teraz
    long taskTime2 = System.currentTimeMillis() + 3000;

    // Utworzenie timera
    Timer tm = new Timer();

    // Zlecenie pierwszego zadania do wykonania
    // Ma się zacząć JUŻ - podano 0 jako moment startu
    // i powtarzać się co 2 sekundy
    tm.schedule(msgTask1, 0, 2000);

    // Zlecenie drugiego zadania do wykonania
    // Zacznie się w momencie określanym przez datę
    // - utworzony obiekt Date; tu - zgodnie z czasem timeTask2
    // ale mogłoby to być np. 11 lipca o 9 rano
    tm.schedule(msgTask2, new Date(taskTime2), 2000);

    // Po twierdzącej odpowiedzi na to pytanie ...
    int rc = javax.swing.JOptionPane.showConfirmDialog(null,
        "Czy kwiaty podlane?");
    // ... kończymy działanie zadania msgTask1
    // do czego służy metoda cancel():
    if (rc == 0) msgTask1.cancel();

    // zadanie 2 nadal działa
    javax.swing.JOptionPane.showMessageDialog(null, "Kończyć trzeba");

    // teraz kończymy wszystko
    System.exit(0);
  }

}

11. Pułapki programowania wspólbieżnego

• za pomocą wywołania metody sleep(...). Uśpienie wątku, nawet na krótko (np. 1/10 sek.) daje szanse dostępu do procesora innym wątkom.
• poprzez zastosowanie metody yield() (np. po wykonaniu jakiejś częsci zadania wątku), która to metoda powoduje oddanie czasu procesora innemu oczekującemu wątkowi, który ma wyższy lub taki sam priorytet