Помогите разобраться с synchronized.

Такой вариант дает разный результат. И чем этот вариант отличается от моего? Получается только если в методе должны быть еще какие-то операции, нужно использовать синхронайзд блок, но в моем случае это только операция инкремента.

Отличается тем, мьютекс какого объекта будет заблокирован. Но поскольку сами операции с Integer не атомарные, то гарантии опять же не будет. Для этого и созданы Atomic-классы.

В вашем варианте блокируется мьютекс объекта VolatileTest.count, если я правильно понимаю. А в моем варианте мьютекс какого объекта будет заблокирован? Не понимаю что-то.

public synchronized void countIncrement() {
        VolatileTest.count++;
    }

В твоем варианте блокируется this, объект, у которого вызывается метод (то есть Jumps). Вот если бы у счетчика был специальный метод, который бы его изменял, и этот метод был synchronized, то блокировался бы мьютекс счетчика. Например:

public class VolatileTest {
    public static CountObject count = new CountObject(0);

    public static void main(String[] args) throws InterruptedException {
//    ...
    }
}

class Jumps implements Runnable {
    @Override
    public void run() {
        VolatileTest.count.incrementCount();
    }
}

class CountObject {
    Integer value;
    public CountObject(Integer value) {
        this.value = value;
    }

    public synchronized void incrementCount() {
        value = value + 1;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

Спасибо за ответ. Не совсем понял про блокировку мьютекса this. Например если бы у меня был такой код, то нити не смогли бы работать одновременно в методах countIncrement() и countDecrement() из-за блокировки мьютекса this?

class Jumps implements Runnable {
    @Override
    public void run() {
        /*
        some logic.....
         */
        this.countIncrement();

        /*
         some logic......
         */
        countDecrement();
    }

    public synchronized void countIncrement() {
        VolatileTest.count++;
    }

    public synchronized void countDecrement() {
        VolatileTest.count--;
    }
}

Нет. Поскольку this для разных нитей были бы разными (у каждой нити свой Jumps), это никак бы не мешало их одновременной работе. Поэтому в такой синхронизации особого смысла нет.

Получается т.к this у всех нитей разный, то в метод (код ниже) могут зайти сразу несколько нитей?

public synchronized void countIncrement() {
        VolatileTest.count++;
    }

Да, смогут. Можешь убедиться, например, так:

public class VolatileTest {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            Thread thread1 = new Thread(new Jumps("object " + i));
            thread1.start();
        }
    }
}

class Jumps implements Runnable {
    private String name;

    public Jumps(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        print();
    }

    public synchronized void print() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + ": step " + i);
        }
    }
}

Спасибо за разъяснения, стало понятнее! Но возник вопрос, а зачем вообще делать методы synchronized, если в такие методы все равно могут заходить сразу несколько потоков?

Я тебе выше кидала пример кода с CountObject, у которого синхронизированный метод incrementCount. Этот метод не может быть вызван у одного и того же объекта-счетчика одновременно разными нитями. Или можно последний пример преобразовать:

public class VolatileTest {
    public static Printer printer = new Printer();
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            Thread thread1 = new Thread(new Jumps("object " + i));
            thread1.start();
        }
    }
}

class Jumps implements Runnable {
    private String name;

    public Jumps(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        VolatileTest.printer.print(name);
    }
}

class Printer {
    public synchronized void print(String name) {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + ": step " + i);
        }
    }
}

Метод print в классе Printer - синхронизированный. Посмотри, как это будет работать. А потом убери synchronized и посмотри снова. В общем, синхронизировать надо не методы нитей/runnable, а методы тех объектов, которыми нити будут пользоваться.

Понял! Спасибо за разъяснения!

volatile тут не поможет

да, я уже проверил

Спасибо за ответ. Если я правильно понял, Atomic.... нужно использовать всегда, когда ты знаешь, что нити могут не только читать, но и изменять переменную?

да, Атомарные числа как раз для этого и сделаны.