How reordering of instructions can cause concurrency issue

I was reading about JMM (Java Memory Model) and I could understand that how flushing of the cache variables can cause other threads to have dirty reads. It was also mentioned that re-ordering of instructions can cause concurrency issues, even though I understood what is meant by re-ordering of the instructions I wouldn't understand how it can cause concurrency issues.

For example, suppose thread t1 has acquired lock while starting test1(), now even if compiler has done some optimization and there is some re-ordering because of which z = 4; has gone either up or down, now since t2 wouldn't get the lock for test2() until there t1 has released, so how re-ordering in test1() (and even in test2()) could cause concurrency issues/bugs?

public class Testing {
    private int z = 2;

    public synchronized void test1(){
        //some statement..
        z = 4;
        //some statement..
    }

    public synchronized void test2(){
        //some statement..
        System.out.println(z);
        //some statement..
    }
}

EDIT: Please discard my code snippet because after looking at comments it doesn't hold good now, and my updated question is as above.