Bonne façon de synchroniser la liste de tableaux en java

Je ne suis pas sûr si c'est le bon moyen de synchroniser mon ArrayList.

J'ai un ArrayList in_queue qui est transmis à partir de la registerInQueue fonction.

ArrayList<Record> in_queue = null;

public void registerInQueue(ArrayList in_queue)
{
    this.in_queue = in_queue;
}

Maintenant, je suis en train de le synchroniser. Est-ce sychronizing mon in_queue objet correctement?

List<Record> in_queue_list = Collections.synchronizedList(in_queue);

synchronized (in_queue_list) {
    while (in_queue_list.size() > 0) {
        in_queue_list.remove(0);
    }
}
  • Vous ne pouvez pas vraiment de mise à niveau, d'une liste synchronisée parce que vous êtes passé à une référence, de sorte que vous n'avez pas vraiment le posséder. Quelle que soit vous a donné la référence pourrait toujours modifier la liste initiale, il est passé à vous en même temps. Indépendamment de ce que la synchronisation vous permet d'ajouter, sauf si c'est explicitement connu que la liste va être gardé par sa intrinsèque de verrouillage.
  • Je vais mettre un bloc synchronisé autour de toute opération sur la file d'attente. Merci!
InformationsquelleAutor bob | 2009-09-16
  1. 44

    Vous synchronisez deux fois, ce qui est inutile et, éventuellement, ralentit le code: modifications lors de l'itération sur la liste besoin d'un synchronnization sur l'ensemble de l'opération, qui vous sont faites avec synchronized (in_queue_list) à l'Aide de Collections.synchronizedList() est superflu dans ce cas (il crée un wrapper qui synchronise les opérations individuelles).

    Cependant, puisque vous êtes de vider complètement la liste, les itérées de suppression du premier élément est la pire façon possible de le faire, sice pour chaque élément tous les éléments suivants doivent être copiés, ce qui en fait un O(n^2) fonctionnement - horriblement lent pour les grandes listes.

    Au lieu de cela, il suffit d'appeler clear() - pas d'itération nécessaire.

    Edit:
    Si vous avez besoin de la seule méthode de synchronisation de Collections.synchronizedList() plus tard, c'est la façon correcte:

    List<Record> in_queue_list = Collections.synchronizedList(in_queue);
in_queue_list.clear(); //synchronized implicitly,

    Mais dans de nombreux cas, la seule méthode de synchronisation est insuffisant (par exemple, pour tous itération, ou lorsque vous obtenez une valeur, faire des calculs fondés sur elle, et de le remplacer par le résultat). Dans ce cas, vous devez utiliser la synchronisation manuelle de toute façon, donc Collections.synchronizedList() est juste inutile de surcharge supplémentaire.

    • La synchronisation de deux fois ici n'est pas inutile: il garantit que, si la boucle est en cours d'exécution personne d'autre ne peut modifier la liste. Pas à l'aide de clear() est un peu over-the-top, mais. 🙂
    • donc, je devrais faire quelque chose comme: synchronisée ((Liste)in_queue) ?
    • Ok! J'ai effectivement enlevé un peu de code pour faire simple. Je ne vais pas avoir un problème avec clear()/supprimer(). merci =]
    • non, c'est complètement inutile. Comme je l'ai écrit, l'utilisation des Collections.synchronizedList() est superflu
    • Quand j'essaie de la synchronisation manuelle, je reçois un message d'erreur "champ non statique de la finale" lorsque j'utilise synchronisée (in_queue). Cela devrait-il être remplacé par synchronisée ((Liste)in_queue) ?
    • Non, ce n'est pas d'obtenir quoi que ce soit. Quel est le message d'erreur exact et à ce que la ligne passe-t-il? Le message d'erreur "champ non statique de la finale" ne peut pas être trouvé via Google, donc je doute que ce que vous obtenez en fait.

    InformationsquelleAutor Michael Borgwardt
  2. 8

    À la recherche à votre exemple, je pense que ArrayBlockingQueue (ou ses frères et sœurs) peut être utile. Ils regardent après la synchronisation, pour vous, de sorte que les fils peuvent s'écrire de la file d'attente ou peek/prendre sans plus de synchronisation de travail sur votre partie.

    • Merci pour la suggestion! C'est ce que je suis en train de faire, vous ne savez pas à propos de la limitation de la taille de mon tableau si. Je vais garder cela à l'esprit. 😉
    • Remarque il y a un LinkedBlockingQueue ainsi. Et vous n'avez pas nécessairement besoin d'imposer des limites.
    • merci, je me souviendrai de cette =]
    InformationsquelleAutor Brian Agnew
  3. 5

    Qui est correcte, et documenté:

    http://java.sun.com/javase/6/docs/api/java/util/Collections.html#synchronizedList(java.util.Liste)

    Cependant, pour effacer la liste, il suffit d'appeler Liste.clear().

    InformationsquelleAutor Andrew Duffy
  4. 5

    Oui, c'est la façon correcte, mais le bloc synchronisé est nécessaire si vous voulez que tous les prélèvements ensemble pour être sûr - à moins que la file d'attente est vide, pas de suppressions permis. Ma conjecture est que vous voulez juste coffre-fort et de file d'attente file d'attente des opérations, de sorte que vous pouvez supprimer le bloc synchronisé.

    Cependant, il y a beaucoup avancé simultanées files d'attente en Java comme ConcurrentLinkedQueue

    InformationsquelleAutor David Rabinowitz
  5. 1

    Prenons une liste normale (mis en œuvre par la classe ArrayList) et synchronisés. Ceci est illustré dans le SynchronizedListExample classe.
    Nous passons les Collections.synchronizedList une nouvelle méthode de liste de tableaux de Chaînes de caractères. La méthode renvoie un synchronisé Liste de Chaînes de caractères.
    //C'est ici SynchronizedArrayList classe 

    package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.apache.log4j.Logger;
/**
* 
* @author manoj.kumar
* @email [email protected]
* 
*/
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
    public static void main(String[] args) {    
        List<String> synchronizedList = Collections.synchronizedList(new ArrayList<String>());
        synchronizedList.add("Aditya");
        synchronizedList.add("Siddharth");
        synchronizedList.add("Manoj");
        //when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<String> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Synchronized Array List Items: " + iterator.next());
            }
        }    
    }
}

    Notez que lors de l'itération sur la liste, cet accès se fait toujours à l'aide d'un bloc synchronisé que les verrous sur la synchronizedList objet.
    En général, une itération sur un synchronisé collection doit être fait dans un bloc synchronisé

    InformationsquelleAutor