Can static variables ever be used to synchronize threads?

Question

Below I have constructed an example which synchronizes three threads based on a static variable:

public class CallMethodsInOrder {

    public static void main(String[] args) {
        // Three instances of Thread, first calls first, second second and third third.
        // Ensure that they are all called in order.

        Thread first = new Thread(new FooRunner(new Foo(),MethodToCall.FIRST));
        Thread second = new Thread(new FooRunner(new Foo(),MethodToCall.SECOND));
        Thread third = new Thread(new FooRunner(new Foo(),MethodToCall.THIRD));

        third.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        second.start();
        first.start();
    }
}

class Foo {
    static boolean hasFirstRun = false;
    static boolean hasSecondRun = false;
    static boolean hasThirdRun = false;

    public Foo() {
    }

    public void first() {
        System.out.println("First");
        hasFirstRun = true;
    }

    public void second() {
        System.out.println("Second");
        hasSecondRun = true;
    }

    public void third() {
        System.out.println("Third");
        hasThirdRun = true;
    }
}

class FooRunner implements Runnable{

    private Foo foo;
    private MethodToCall method;

    public FooRunner(Foo foo, MethodToCall method) {
        this.foo = foo;
        this.method = method;
    }

    @Override
    public void run() {
        if(method == MethodToCall.FIRST) {
            foo.first();
        }
        else if (method == MethodToCall.SECOND){
            while(!Foo.hasFirstRun) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            foo.second();
        }
        else if (method == MethodToCall.THIRD) {
            while(!Foo.hasSecondRun) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            foo.third();
        }
    }
}

enum MethodToCall{
    FIRST, SECOND, THIRD;
}

Is this a valid approach? I have read that static variables are not thread safe, however, cannot see a situation in which the above code would not execute the three methods in the desired order (first, second, third).

Many answers I have found have been related to accessing data structures with multiple threads vs ordering of methods as displayed here.

Since each static variable is only being modified by a single thread is it a problem?

Answer 1

As suggested in the comments, using synchronized is likely the way forward here. I feel the above code still works with static variables however is definitely not the best practise.

A related solution including Semaphores is included below:

public class CallMethodsInOrder2 {

    public static void main(String[] args) {
        // Three instances of Thread, first calls first, second second and third third.
        // Ensure that they are all called in order.

        // This approach uses Semaphore vs static variables.

        Foo2 foo2 = new Foo2();

        Thread first = new Thread(new FooRunner2(foo2,MethodToCall.FIRST));
        Thread second = new Thread(new FooRunner2(foo2,MethodToCall.SECOND));
        Thread third = new Thread(new FooRunner2(foo2,MethodToCall.THIRD));

        third.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        second.start();
        first.start();
    }

}

class Foo2 {
    private Semaphore one, two;

    public Foo2() {
        one = new Semaphore(1);
        two = new Semaphore(1);

        try {
            one.acquire();
            two.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void first() {
        System.out.println("First");
        one.release();
    }

    public void second() {
        try {
            one.acquire();
            System.out.println("Second");
            one.release();
            two.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void third() {
        try {
            two.acquire();
            two.release();
            System.out.println("Third");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Answer 2

I think the static variable method 'works' in this case (for some value of 'works'), but is definitely less efficient.

You're sleeping an arbitrary amount of time in each thread ('100'), and then waking up to poll this variable. In the case of a semaphore, the OS takes care of the sleep/wake events to the threads.