Visibilité de la mémoire dans la fourche-join

Question

Brian Goetz a écrit un article de Nice sur fourche à se joindre http://www.ibm. com / developerworks / java / bibliothèque / j-jtp03048.html . Dans ce document, il énumère un algorithme de tri par fusion à l'aide du mécanisme de fourche se joindre, dans lequel il effectue le tri sur les deux faces d'un réseau en parallèle, fusionne alors le résultat.

L'algorithme trie sur deux sections différentes d'un même réseau simultanément. Pourquoi n'est pas un AtomicIntegerArray ou un autre mécanisme nécessaire pour maintenir la visibilité? Quelle garantie est-il qu'un fil verra les écritures faites par l'autre, ou est-ce un bug subtilement? En tant que suivi, ne ForkJoinScheduler Scala font également cette garantie?

Merci!

Answer 1

La jointure (de ForkJoin) lui-même a besoin d'un point de synchronisation, thats la pièce la plus importante de l'information. Un point de synchronisation veillera à ce que toutes les écritures qui se produisent sont visibles après ledit point.

Si vous regardez le code que vous pouvez voir où le point de synchronisation se produit. Ceci est juste un appel de méthode invokeAll

public static void invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2) {
    t2.fork();
    t1.invoke();
    t2.join();
}

Voici t2 fourches dans un autre processus, t1 exécute sa tâche et que thread appelant attendra sur t2.join (). Lors du passage t2. Toutes les écritures à t1 et t2 seront alors visibles.

Edit:. Cette édition est juste pour donner un peu plus d'une explication de ce que je voulais dire par point de synchronisation

Disons que vous avez deux variables

int x;
volatile int y;

Chaque fois que vous écrivez à y toutes les écritures qui se sont produits avant de lire y seront disponibles. Par exemple

public void doWork(){
   x = 10;
   y = 5;
}

Si un autre thread lit y = 5 que le fil est garantie lire x = 10. En effet, l'écriture à y crée un point de synchronisation dans lequel toutes les écritures avant ledit point sera visible après l'écriture.

Avec la piscine Rejoignez Fork la jointure d'un ForkJoinTask va créer un point de synchronisation. Maintenant, si t2.fork () et t1.invoke () la jonction de t2 veillera à ce que toutes les écritures qui, auparavant, se sont produits seront vus. Étant donné que toutes les écritures précédentes sont dans la même structure, il sera sans danger pour la visibilité.

Je serais heureux d'expliquer plus en détail si ce ne est pas aussi clair.

Answer 2

Juste une supposition. Fusion comprend assemblage sur un fil, et la jointure garantit la visibilité

La seconde partie est sûr; Je ne sais pas comment est la fusion mise en œuvre.