Esta pergunta foi feita repetidas vezes, mas ainda tenho uma dúvida. Quando as pessoas dizem que sincronizado cria uma barreira de memória, a que essa barreira de memória se aplica? QUALQUER variável em cache? Isso não parece viável.

Então, devido a essa dúvida, escrevi um código que se parece com isso:

final AtomicReferenceArray<Double> total=new AtomicReferenceArray<Double>(func.outDim);
for(int i=0; i<func.outDim; i++) total.set(i, 0.);
for(int i=0; i<threads; i++){
    workers[i]=new Thread(new Runnable(){
        public void run() {
            double[] myPartialSum=new double(func.outDim);
            //some lengthy math which fills myPartialSum...

            //The Atomic* guarantees that I'm not writing local copies of the Double references (whose value are immutables, so it's like an array of truly volatile doubles) in variable total, synchronized(total) atomizes the sum
            synchronized(total){ for(int i=0; i<func.outDim; i++) total.set(i, total.get(i)+myPartialSum[i]); }
        };
    workers[i].start();
}
//wait for workers to terminate...

//print results accessing total outside of a synchronized(total) block, since no worker is alive at this point.

Gostaria de saber se é possível substituir apenas o tipo de total por um duplo simples []: isso exigiria que sincronizado (total) (no método run ()) garanta que não estou trabalhando com cópias locais de cada índice em a matriz de duplas, ou seja, a cerca de memória não se aplica apenas ao valor detotal em si (que está sob o capô um ponteiro), mas para os índices detotal também. Isso acontece?