mot clé synchronisé et verrous sur les méthodes d'instance

J'étudie la concurrence en ce moment et j'apprenais à bloquer les threads.

Je sais qu'un thread peut arriver à un état bloqué lorsque la tâche attachée correspondante tente d'accéder à une méthode qui est verrouillée parce qu'un autre thread a acquis le verrou.

Donc, d'après ce que j'ai lu les blocs de tâches et attendez qu'il puisse accéder à cette méthode et ainsi de suite avec ses activités (à savoir, le reste de la méthode run ()).

Alors pourquoi ce code se termine comme si la tâche pourrait appeler syn.getI () et accéder à la variable dans un état "erroné" (même si la méthode syn.manipulate () est verrouillée, donc je suppose que la tâche ne peut pas appeler getI ())? où est-ce que je me trompe?

public class SynchronizedClass {
    private int i;
    private boolean flag=true;
    public SynchronizedClass(int i){
        this.i=i;
    }
    public int getI(){
        return i;
    }
    public boolean getFlag(){
        return flag;
    }
    public synchronized void manipulate(){
        i=(i*2)+1;  //odd number
        Thread.yield();
        i= i+1; //even number       
    }
    public void close(){
        flag=false;
    }

}
public class MyThread implements Runnable {
    //auto-managed runnable
    Thread t;
    SynchronizedClass syn;
    public MyThread(SynchronizedClass syn){
        this.syn=syn;
        t=new Thread(this);
        t.start();
    }
    @Override
    public void run() {
        while(syn.getFlag()==true){
            syn.manipulate();
            if (syn.getI()%2!=0){
                syn.close();
                System.out.println("exit");
            }

        }

    }
    public static void main(String[] args) {
        SynchronizedClass syn = new SynchronizedClass(1);
        for(int i=0;i<4;++i)
            new MyThread(syn);
    }
}