¿Cómo son todos los posibles valores resultantes de una explicable "Strangeloop"?

ndsvw:

Dado un -code "Strangeloop" de esta manera:

2 Hilos corren a través de un bucle (cada uno) y que reciben y fijan el valor de un objeto de la clase MiEntero:

¿Qué resultados / productos son posibles?

class MyInteger
{
    private int value;

    public synchronized int getValue()
    {
        return value;
    }

    public synchronized void setValue(int value)
    {
        this.value = value;
    }
}

public class StrangeLoop extends Thread
{
    private MyInteger data;

    public StrangeLoop(MyInteger data)
    {
        this.data = data;
    }

    public void run()
    {
        for (int i = 1; i <= 10; i++)
        {
            int local = data.getValue();
            local++;
            data.setValue(local);
        }
    }

    public static void main(String[] args)
    {
        MyInteger data = new MyInteger();
        StrangeLoop t1 = new StrangeLoop(data);
        StrangeLoop t2 = new StrangeLoop(data);
        t1.start();
        t2.start();
        try
        {
            t1.join();
            t2.join();
        }
        catch (InterruptedException e)
        {
        }
        System.out.println("Final value: " + data.getValue());
    }
}

Si un hilo corre a través de su bucle después de que el otro hilo ya lo ha hecho, la salida del programa debe ser Final value: 20.

Pero, ¿qué podría salir mal? Resultados como 10,11, 19 ... también son posibles (si el sistema operativo cambia entre los hilos).

Los valores entre 10 y 20 son posibles? Hasta ahora, lo entiendo.

Pero la solución correcta de este ejercicio es: Cualquier salida entre 2 y 20 es posible. No entiendo cómo 2 (por ejemplo) debería ser posible.

Andy Turner:

Tiene dos hilos, T1 y T2. cada uno que van a hacer 10 lecturas (10R) y 10 escribe (10W). Debido a que la lecturas y escrituras están sincronizados, se puede garantizar que no se producen en paralelo; y que el valor previamente escrito es visible en la siguiente leer de cualquiera de hilo.

• T1 lee el valor 0
• T2 lee y escribe el valor 9 veces (el valor es ahora 9)
• T1 escribe el valor 1

T1 ha hecho 1R, 1W; T2 ha hecho 9R, 9W.

• T1 lee el valor 1
• T2 lee el valor 1

(O al revés: el ordenamiento de estos dos es poco importante)

T1 ha hecho 2R, 1W; T2 tiene 10R hecho, 9W.

• T1 escribe 2, a continuación, lee y escribe 8 veces

T1 tiene 10R hecho, 10W.

• T2 escribe el valor 2.

T2 tiene 10R hecho, 10W.

El valor por último escrito es 2, según sea necesario.