Não consigo descobrir por que o código não funciona corretamente. O problema é que ReentrantLock não bloqueia a chamada de métodos em ThreadClass.run ()

Classe de recurso que métodos são considerados bloqueados em ThreadClass

public class ResourceClass {

    private int i; 

    public void setIncrement() {
        i++;
    }

    public int getIncrement() {
        return i;
    }

}

Classe de thread

public class ThreadClass implements Runnable {

    private ResourceClass resource;
    private ReentrantLock reentrantLock = new ReentrantLock();

    ThreadClass(ResourceClass r) {
        resource = r;
    }

    public void run() {
        reentrantLock.lock();
        try {
            resource.setIncrement();
            System.out.println(resource.getIncrement());
        } finally {
            reentrantLock.unlock();
        }
    }

}

Classe principal

public class MainClass {

    public static void main(String[] args) {

        ResourceClass resource = new ResourceClass();

        Thread thread = new Thread(new ThreadClass(resource));
        thread.start();
        Thread thread2 = new Thread(new ThreadClass(resource));
        thread2.start();
        Thread thread3 = new Thread(new ThreadClass(resource));
        thread3.start();
    }

} 

Supõe-se que o código cercado por lock in run () deve ser "sincronizado", resultando em que apenas um thread tenha acesso aos métodos de Resourse-objeto. Na prática, não. O código resulta em números repetidos, o que significa que dois threads têm acesso aos métodos ao mesmo tempo. Eu sei que é uma questão realmente simples, mas não consigo entender como resolvê-lo. Obrigado pela ajuda.

Atualizar:

Eu entendi. Esse trecho de código funciona bem (eu excluí setIncrement () e coloquei toda a lógica relevante em getIncrement ()):

public int getIncrement() {
        reentrantLock.lock();
        int incrementResult = i++;
        reentrantLock.unlock();
        return incrementResult;
}