r[3][500] are initialized.

int computePot() {
   int i, j;

   for( i=0; i<500; i++ ) {
      for( j=0; j<i-1; j++ ) {
        distx = pow( (r[0][j] - r[0][i]), 2 );
        disty = pow( (r[1][j] - r[1][i]), 2 );
        distz = pow( (r[2][j] - r[2][i]), 2 );
        dist = sqrt( distx + disty + distz );
        pot += 1.0 / dist;
      }
   }

I doubt that If this code really can be optimized?

distx = pow( (r[0][j] - r[0][i]), 2 );

into

distx = (r[0][j] - r[0][i]) * (r[0][j] - r[0][i]);

pow is slower than a normal multiplication.

[/quote]

Its not much, but change the second for-loop condition like so. Reason: The calculation (i-1) probably will be executed on every iteration of the loop. Than again this are roughly 125k iterations, so every single bit counts

float InvSqrt( float f )
{
	float y, r;
	int i;

	y = f * .5f;
	i = *reinterpret_cast< int *>( &f );
	i = 0x5f3759df - ( i >> 1 );
	r = *reinterpret_cast< float *>( &i );

	r = r * ( 1.5f - r * r * y );

	return r;
}

Now the division can be removed from your code:

pot += InvSqrt( distx + disty + distz );

this is my way to accelerate the code, it works when config as debug, but will be block(without any response and mistake) when config as release. I'm confused. anyway, thanks you guys who reply me. and sorry for my poor english, I'm come from China.

A condition variable should be exactly what you need. If you're working with Win32 you can easily use an EVENT in this situation.

A barrier is not 100% what you need, but it comes close, and it should be very easy to use. It blocks all threads that "hit" the barrier (i.e. call the "hit" function or however it's called) until exactly N threads have hit the barrier (where N is configurable e.g. upon creation). When the N-th thread hits the barrier, all N threads will continue (i.e. the N-th thread will just "run through" the barrier, releasing all others).

you could replace your postfix increment operators in the "for loops" by prefix increment operators (i++ ==> ++i)

Sry, but that's a common misbelief. There's no difference in the perfomance of pre- or postfix operators with POD types.
It only gives you a benefit when using iterators.
But it's good practice to always use prefix operators as there's no sideeffect in this case.