Initialization safety in java

Just to make sure I understand the concepts presented in java concurrency in practice.

Lets say I have the following program:

public class Stuff{
    private int x;

    public Stuff(int x){
        this.x=x;
    }

    public int getX(){return x;}
}

public class UseStuff(){
    private Stuff s;

    public void makeStuff(int x){
        s=new Stuff(x);
    }

    public int useStuff(){
        return s.getX();
    }
}

If I let multiple threads to play with this code, then I'm not only in trouble because s might be pointing to multiple instances if two or more threads are entering to the makeStuff method, but even if just one thread creates a new Stuff, then an other thread who is just entered to useStuff can return the value 0 (predefined int value) or the value assigned to "x" by its constructor.

That all depends on whether the constructor has finished initializing x.

So at this point, to make it thread safe I must do one thing and then I can choose from two different ways.

First I must make makeStuff() atomic, so "s" will point to one object at a time.

Then I either make useStuff synchronized as well which ensures the I get back the Stuff object x var only after its constructor has finished building it, OR i can make Stuff's x final, and by this the JMM makes sure that x's value will only be visible after it has been initialized.

Do I understand the importance of final fields in the context of concurrency and JMM?