¿Es una operación de movimiento en Unix atómico?

Supongamos que hay 2 procesos P1 y P2, y acceden a un archivo compartidoFoo.txt.

Supongamos que P2 está leyendo deFoo.txt. No quiero que P1 escriba aFoo.txt mientras P2 lo está leyendo.

Así que pensé que podría hacer P1 escribir aFoo.tmp y como ultimo paso, renombrarFoo.tmp aFoo.txt. Mi lenguaje de programacion es java

Así que mi pregunta es, ¿garantizaría esto que P2 lea los datos correctos deFoo.txt? ¿Se confirmaría la operación de cambio de nombre una vez que P2 complete la lectura del archivo?

EDITAR

Intenté recrear este escenario de la siguiente manera:

Mi código P1 es algo como esto:

File tempFile = new File(path1);
File realFile = new File(path2);
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
for(int i=0;i<10000;i++)
    writer.write("Hello World\n");
writer.flush();
writer.close();
tempFile.renameTo(realFile);

y mi código P2 es:

BufferedReader br = new BufferedReader(new FileReader(file)); 
String line = null;
while(true) {
  while((line=br.readLine())!=null){
      System.out.println(line);
      Thread.sleep(1000);
  }
  br.close();
}

Mi archivo compartido de muestra:

Test Input
Test Input
Test Input   

Estoy empezando P1 y P2 casi simultáneamente (P2 comienza primero).

Así que, según tengo entendido, aunque P1 ha escrito un nuevo Foo.txt, ya que P2 ya lo está leyendo, debería leer el contenido anterior de Foo.txt hasta que vuelva a abrir un BufferedReader a Foo.txt.

Pero lo que realmente sucede es que P2 lee.Test Input tres veces, como se espera de la entrada, pero después de eso lee el nuevo contenido que fue escrito por P1.

Salida de P2:

Test Input
Test Input
Test Input 
Hello World
Hello World
Hello World
 .
 .
 .

Así que no funciona como debería. ¿Estoy probando este escenario mal? Siento que hay algo que me estoy perdiendo.