What's the difference between these options?"

Take this code for example:

public class Test {
    public static void main(String[] args) {
        Test obj1 = new Test();
        Test obj2 = new Test();

        Thread t1 = new Thread(new TestRunnable(obj1), "Thread 1");
        Thread t2 = new Thread(new TestRunnable(obj1), "Thread 2");
        Thread t3 = new Thread(new TestRunnable(obj2), "Thread 3");
        Thread t4 = new Thread(new TestRunnable(obj2), "Thread 4");

        t1.start(); t2.start(); t3.start(); t4.start();
    }

    void test() throws Exception{
        synchronized (this){
            System.out.println(Thread.currentThread().getName() + " is in the method");

            while (true) {
                Thread.sleep(1000);
            }
        }
    }


}

class TestRunnable implements Runnable {
    Test obj;

    public TestRunnable(Test obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        try {
            obj.test();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

This code creates has a custom thread that calls the test() method on the object instance passed to it. The test() method simply prints the thread in the synchronized block then infinitely waits. First 2 Test objects are created, then 4 threads are created with the first two using the first object then the next two use the second created object. If you run it you will see either thread 1 or 2 will output and either thread 3 or 4 will output (whichever reaches the lock first). So synchronized (this) is only for each individual object created. you could remove the synchronized block and make it a synchronized method instead and the result wouldn't change since a synchronized method is the same as having all the code in a method within a synchronized(this) block. If I created 4 objects instead of 2 and passed each one to one of the 4 threads then all 4 would output that they reached the synchronized block.

If you wanted to lock that method for threads no matter what object is being used then you would need a class lock or a static lock

Thank you so much, this course need more explanation like that.

In addition to that... if tasks need to communicate they need a shared object. That shared object you pass to the Runnable (or make it accessible in another way like using a property in an outer class). If all this threads access that shared object at the same time you get unexpected results. You need to take care that just one thread at a time can access the shared data. In most cases using this as lock may be enough (like if you code the shared object yourself and inside of it you of course can use this). If you're in a static context, like in my example below that doesn't work.

public class Locking {

    public static void main(String[] args) throws Exception {
        ArrayList<Integer> sharedList = new ArrayList<>();
        sharedList.add(-1);

        List<Thread> threads = IntStream.range(0, 5)
                .mapToObj(e -> new Thread(() -> { // have to use a lambda for the Runnable because of the char limit

                    // here you can not lock using this, you either lock on class level, use the sharedList or a
                    // dedicated lock object. However, using the list is better readable imho
                    synchronized (sharedList) {
                        sharedList.add(e);
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException ignore) {}
                        sharedList.remove(Integer.valueOf(e));
                    }
                }))
                .collect(Collectors.toList());

        // start and join threads
        threads.forEach(Thread::start);
        for (Thread t : threads) {
            t.join();
        }

        // output to verify correct execution
        // remove synchronization to see unexpected results
        // expected: the initially added -1
        System.out.print("sl content: ");
        System.out.println(sharedList);
    }
}

Thanks Thomas for great example to experiment with :D I tried use lock : "Locking.class" and it's work the same. Does that mean when I use the class lock, it locks every object from that class? Thanks guys, together we fight against multithreading 😎👊

Class level: it prohibits access no matter where the task has been created. To demonstrate that, the example is not good enough as the threads get created in main. Imagine it that way, each object and classes, too, have a boolean isLocked variable (in reality it is a counter variable incremented each time you access a synchronized block. When you access another synchronized method from inside a synced block the counter is eg. incremented to two). OK, let's stay with the boolean. If you access a synchronized block and you have a lock object, then the isLocked boolean is set to true when you access the synchronized block and set to false when you leave. That's the same for the class level. So it does not matter from where you access that block, from the same class you used as lock or another one. You only have that one boolean. Means only one thread at a time can enter the block. If it is a different object or not. Only one thread at a time can enter the block this: here it is different. Eg. you have a class Holder, that is used as shared object. Inside that Holder class you have synchronized blocks using this as lock. Now you create five threads (A) using holderObject1 and you create five threads (B) using holderObject2. You already see what's happening A and B are independent but all A tasks can access the synchronized holderObject1 only one by one. Same for all B tasks. They can only access holderObject2 one by one. But one A task can access holderObject1 at the same time as a B task can access a holderObject2. If you lock by class (or a dedicated lock object then only one thread can access any holderObject). Means you have doubled the performance using the this example above (if it is possible to code it that way)

practice makes perfect 😀