What does it mean: synchronized (MyClass.class) ?

Thank You, but please confirm that I have understood correctly: synchronized (ClassName.class) { . . . } - this is just a simple notation-form used for locking a specified static block. It does not lock all the static methods in the class, but only this one method/codeblock on which we have placed this notation.

it will lock any static method that is synchronized as well as any block that is locked with the same class level lock. So if one thread held a class wide lock somewhere else in code then:

// whole static methods would be locked if synchronized
static synchronized myMethod(){
   /* some lines of code */
}

// non synchronized methods are not locked
static myMethod1(){
   /* some lines of code */

   // code in synchronized block with a class clock is locked.
   // The lock will hold the thread at wait until unlocked  so
   // code below the block would be on hold during that wait
   synchronized(ClassName.class){
       /* some lines of code */
   }

   /* some lines of code */
}

// non static methods are not locked with a class level lock
synchronized myMethod3() {

   // synchronized blocks on object level won't be locked
   synchronized(this){
       /* some lines of code */
   }

   // but a synchronized block locked with a class lock will be
   synchronized(ClassName.class){
       /* some lines of code */
   }
}

There is a synchronized block locked with a class lock inside an instance method (in myMethod3)? I can't understand what does this means.

what don't you understand? It's valid code to have a class locked block in an instance method. You can't have an object locked block of code is a static method though because static methods aren't part of any instance. Have you ever played doom from the early 90's? They have color coded doors that are locked until you pick up the corresponding color coded key. This is very similar except that its locking instead of unlocking. When a thread enters a synchronized block/method it locks ALL the other blocks/methods that are locked with the same type (object level, class level, or a even specific object) no matter where they appear.

This was the key for me: "When a thread enters a synchronized block/method it locks ALL the other blocks/methods that are locked with the same type (object level, class level, or a even specific object) no matter where they appear." It's clear now.

=) If your head is spinning now trying to wrap your head around concurrency, let me assure you that after three years of programming Java (with 5 years prior programming experience on top of that), I still don't fully understand it.

:-) These are "encouraging" prospects...

But one more question from this lecture: https://codegym.cc/quests/lectures/questcore.level07.lecture03. They write in the example: Code of the first thread: (inside a synchronized block!) 1 String s1 = name1; 2 name1 = name2; 3 //other thread is running 4 name2 = s1; Code of the second thread: (inside a synchronized block!) 1 //the thread waits until the mutex is unlocked 2 String s2 = name1; 3 name1 = name2; 4 //other thread is running 5 //other thread is running 6 name2 = s2; But they write in the lecture: "No other thread can enter this block until our thread leaves it." But then how is it possible to have such lines: //other thread is running ?? Second thread can't enter this block until first thread finishes it!

The first box on that describes the code working in order: String s1 = name1; //Ally name1 = name2; //Lena name2 = s1; //Ally String s2 = name1; //Lena name1 = name2; //Ally name2 = s2; //Lena The second two boxes describe the events, but the don't mean that they are happening consecutively. Check the example from 2 lessons ago, the one with the same code but without the synchronizes: Level7 lesson 1 It shows the sequence as: String s1 = name1; //Ally name1 = name2; //Lena String s2 = name1; //Lena(!) name1 = name2; //Lena name2 = s1; //Ally name2 = s2; //Lena

OK, then I'd rather not deal with the second two boxes. The point is that the two threads do their own work one after the other, in the expected order.