Wątek może posiadać 2 blokady?

Odpowiedz Nowy wątek
2019-01-17 17:00
1

Witam

W poniższym kodzie wywołuje metodę synchronized, która zakłada blokadę na obiekt R2. Wewnątrz tej metody zakładam kolejną blokadę wewnątrz bloku synchronized na inny obiekt. Program działa tak jak powinien i jestem zaskoczony. Co de facto się dzieje wewnątrz metody run obiektu R2? Jeżeli zamiast synchronized(r1) napiszę synchronized(this) program wyrzuci wyjątek IllegalMonitorStateException. Rozumiem to tak, że poprzez wywołanie metody run() obiekt R2 zyskuje dla siebie blokadę. Następnie w ciele metody wywołuje wywołuje blok synchronizowany względem obiektu r1 czyli obiekt R2 ma 2 blokady?

class R1 implements Runnable {
    { Thread.currentThread().setName("R1"); }
    @Override synchronized public void run() {
       try {
           while(true){
               Thread.sleep(5000);
               System.out.println("zadanie R1 start()");
               wait();
            }
       }
       catch(InterruptedException e) {
           System.out.println("przerwanie: " + e);
       }
       System.out.println("R1 wyjscie z wait()");
    }
}

class R2 implements Runnable {
    { Thread.currentThread().setName("R2"); }
    private R1 r1;
    public R2(R1 r1) {
        this.r1 = r1;
    }
    @Override synchronized public void run() {
       try {
           while(true) {
               System.out.println("zadanie R2 start");
               Thread.sleep(5000);

               synchronized(r1) {           //  synchronized(this) nie działa  - zglasza wyjatek IllegalMonitorStateException. 
                   r1.notify();
               }
           }
       }
       catch(InterruptedException e) {
           System.out.println("przerwanie R2: " + e);
       }
       System.out.println("R2 wyjscie z wait()");
    }
}

public class WaitNotifyTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {

        FLAG flag = new FLAG(true);

        R1 r1 = new R1();
        R2 r2 = new R2(r1);
        ExecutorService exec = Executors.newCachedThreadPool();

        exec.execute(r1);
        Thread.sleep(1000);
        exec.execute(r2);

        exec.shutdown();

    }

}
edytowany 1x, ostatnio: Kuben, 2019-01-17 17:00

Pozostało 580 znaków

2019-01-17 22:28
1

W telegraficznym skrócie: wątek może wywołać obiekt.wait(), obiekt.notify() czy obiekt.notifyAll() tylko i wyłącznie wtedy, gdy jest wewnątrz jakiegoś bloku synchronized (obiekt). Monitory są reentrant, a więc możesz wejść do bloku synchronized(obiekt) będącego wewnątrz bloku synchronized(obiekt).

Taki kod jest całkowicie poprawny:

class Ideone {
    public static void main (String[] args) {
        Object lock = new Object();
        synchronized(lock) {
            synchronized(lock) {
                System.out.println("Hello, World!");
            }
        }
    }
}

https://www.ideone.com/cFytv0

Przeczytaj mój pseudokod z postu powyżej ( Wątek może posiadać 2 blokady? ) ze zrozumieniem, a dostaniesz odpowiedzi na wszystkie swoje pytania związane z monitorami w Objectach :)

Czyli watęk wykonujący blok synchronized uzyskuje blokade obiektu jaki zostal przekazany do bloku synchronized jako argument. Obiek ten sluzy jako klucz dostępu do kodu zawartego w bloku, tak? A kod w bloku moze nie mieć nic wspólnego z tym obiektem.

Tak. Monitor zabezpiecza przed wejściem do danego kawałka kodu (ściślej: do wszystkich kawałków kodu synchronizowanych tym monitorem, bo tych kawałków kodu może być dowolna ilość), ale w żaden sposób nie wpływa na to jakie dane w tym kawałku kodu obrabiasz. Możesz mieć np popsutą wersję licznika z poprzedniego postu:

class Counter {
  int value = 0;

  int incrementAndGet() {
    synchronized(this) {
      value += 1;
      return value;
    }
  }

  int decrementAndGet() {
    value -= 1;
    return value;
  }
}

Synchronizacja w metodzie incrementAndGet jest daremna jeśli inne wątki będą sobie wykonywać niezsynchronizowaną metodę decrementAndGet. Powyższy kod jest technicznie poprawny pod względem wykorzystania synchronizacji i monitorów w tym sensie, że monitory są poprawnie pozyskiwane i oddawane, nie ma ma w tym kodzie jakichś deadlocków, livelocków czy tym podobnych. Podczas wywoływania metody incrementAndGet w jednym wątku inny wątek (lub inne wątki) może wywoływać metodę decrementAndGet. Nie spowoduje to żadnego wyjątku, ale z dużym prawdopodobieństwem spowoduje błędne wyniki działań na liczniku, zarówno w metodzie otoczonej synchronized(this) jak i tej nieotoczonej.

Podam jeszcze przykład na to, że monitor wcale nie musi chronić ani przed wielowątkowym dostępem do wspólnych danych ani przed wielowątkowym dostępem do wspólnego kodu. Wątki mogą mieć zupełnie różne dane i wykonywać zupełnie różny kod, ale dalej synchronizować się na monitorze. W poniższym kodzie wykorzystuję monitor współdzielony przez dwa wątki, by mogły naprzemiennie wypisywać powitania. Kod:

import java.util.*;
import java.lang.*;
import java.io.*;

public class Main {
    static class Thread1 extends Thread {
        Object lock;
        int counter = 10;

        @Override public void run() {
            try {
                synchronized(lock) {
                    while (true) {
                        System.out.println("Hello from Thread1!");
                        lock.wait();
                        counter -= 1;
                        if (counter == 0) {
                            return;
                        }
                        lock.notify();
                    }
                }
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    static class Thread2 extends Thread {
        Object lock;

        @Override public void run() {
            try {
                synchronized(lock) {
                    lock.notify();
                    while (true) {
                        System.out.println("Hello from Thread2!");
                        lock.wait();
                        lock.notify();
                    }
                }
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
    }
    public static void main (String[] args) throws Exception {
        Object sharedLock = new Object();
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.lock = sharedLock;
        thread2.lock = sharedLock;
        thread1.start();
        Thread.sleep(123);
        thread2.start();
        thread1.join(1234);
        thread2.interrupt();
        thread2.join();
    }
}

Wynik:

Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!
Hello from Thread1!
Hello from Thread2!

https://www.ideone.com/DgIPv3

Gdybyś po prostu przeanalizował pseudokod, który ci przygotowałem to nie byłoby to dla ciebie nic dziwnego.


"Programs must be written for people to read, and only incidentally for machines to execute." - Abelson & Sussman, SICP, preface to the first edition
"Ci, co najbardziej pragną planować życie społeczne, gdyby im na to pozwolić, staliby się w najwyższym stopniu niebezpieczni i nietolerancyjni wobec planów życiowych innych ludzi. Często, tchnącego dobrocią i oddanego jakiejś sprawie idealistę, dzieli od fanatyka tylko mały krok."
Demokracja jest fajna, dopóki wygrywa twoja ulubiona partia.
edytowany 8x, ostatnio: Wibowit, 2019-01-17 23:10

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0