Thread safety for tiny simple functions

[CodeMonkey]

In an attempt to get quicker synchronization, I tried to implement a naive barrier system, using a busy wait, thinking that maybe not invoking system threading code would speed things up:

#include <utility>
#include <boost/thread.hpp>
#include <cmath>
#include <iostream>

const unsigned int lesize = 100000;
const unsigned int letime = 100000;
double v[lesize];
double u[lesize];

struct task
{
   enum state { running = 1, waiting = 0 };
   task(state & my_state, state & other_state, std::pair<unsigned int,unsigned int> interval) : me(my_state), it(other_state), r(interval) {}
   void operator()()
   {
	for(int t = 0; t < letime; ++t)
	{
	   me = running;
	   for(int i = r.first; i < r.second; ++i)
		u[i] = v[i-1] + v[i+1] - 2.0*v[i];
	   me = waiting;
	   while(it == running) /*nothing*/;
	   me = running;
	   for(int i = r.first; i < r.second; ++i)
		v[i] += 0.001 * u[i];
	   me = waiting;
	   while(it == running) /*nothing*/;
	}
   }
 private:
   state & me;
   state & it;
   std::pair<unsigned int,unsigned int> r;
};

int main()
{
   for(int i = 0; i < lesize; ++i)
	v[i] = std::sqrt( ((lesize+3)/2.0)*((lesize+3)/2.0) - (i-lesize/2.0)*(i-lesize/2.0) ); //semicircular arc, as initial condition
   boost::thread_group tg;
   task::state state1, state2;
   state1 = state2 = task::running;

   tg.create_thread( task(state1,state2, std::make_pair(1,lesize/2)) );
   tg.create_thread( task(state2,state1, std::make_pair(lesize/2, lesize-1)) );
   tg.join_all();
   std::cout << "Complete." << std::endl;
}

It hangs indefinitely. But why? Does constant checking block setting?
I posted a whole program so that you can run it without having to spend time.

[Codeplug]

>> But why?
You're not synchronizing access to state1 and state2. In general, when two threads access (read/write) the same memory location, synchronization is required. You have to use the synchronization primitives provided by the threading library.

gg