Technique of using volatile flag as replacement to locking

Recently, I came across a volatile flag technique, which I may avoid from using synchronized or lock.

http://jeremymanson.blogspot.com/2008/11/what-volatile-means-in-java.html

Here is one of the code example of using volatile flag.

Correct Working Example

Thread 1
========
// re-odering will not happen. initialize_var...
// will not move below "volatile_initialization_ready = true"
// statement.
initialize_var1();
initialize_var2();
initialize_var3();
volatile_initialization_ready = true;


Thread 2
========
if (volatile_initialization_ready) {
    use_var1();
    use_var2();
    use_var3();
}

However, I find out I just can't use this technique in certain situation as follow.

Wrong Working Example

Thread 1
========
volatile_going_to_destroy = true;
destroy_var1();
destroy_var2();
destroy_var3();

Thread 2
========
if (volati开发者_Python百科le_going_to_destroy) {
    return;    // ignore.
}

// But Thread 1 still able to perform destroy
// when Thread 2 halt right here. Also, re-ordering might
// happen, where destroy_var1 might move above 
// "volatile_going_to_destroy = true" statement.
use_var1();
use_var2();
use_var3();

I was wondering, is it possible for me to make Wrong Working Example work, but just using volatile, without using synchronized or lock?

---

volatile only solves the visibility problem. You still need locks for synchronization.

---

You can use an algorithm like the following http://en.wikipedia.org/wiki/Dekker%27s_algorithm. It allows for safe variable access with only memory barriers but without locks.