Le thread de la liste de tableaux est-il sécurisé ?

Qu'est-ce qu'un thread dangereux :

La sécurité des threads signifie que lors d'un accès multi-threads, un mécanisme de verrouillage est utilisé pour protéger lorsqu'un thread accède à certaines données de cette classe. accédez-y jusqu'à ce que ce fil ait fini de lire, puis d'autres fils pourront l'utiliser. Il n’y aura pas d’incohérence ou de pollution des données. L'insécurité des threads signifie que la protection de l'accès aux données n'est pas fournie. Il est possible que plusieurs threads modifient les données successivement, ce qui rend les données obtenues sales.

Une ArrayList, lors de l'ajout d'un élément, elle peut être complétée en deux étapes :

1 . élément à l'emplacement de Items[Size];

2. Augmentez la valeur de Size. (Apprentissage recommandé : Tutoriel vidéo Java)

Dans le cas d'un fonctionnement monothread, si Size = 0, après ajout d'un élément, l'élément sera en position 0, et Size = 1;

Et s'il s'agit d'une situation multithread, par exemple, il y a deux threads, le thread A stocke d'abord l'élément en position 0. Mais à ce moment-là, le processeur planifie la pause du thread A et le thread B a la possibilité de s'exécuter. Le thread B ajoute également des éléments à cette ArrayList, car Size est toujours égal à 0 à ce moment (notez que nous supposons que l'ajout d'un élément nécessite deux étapes et que le thread A n'a terminé que l'étape 1), donc le thread B ajoute également des éléments à Stored at emplacement 0. Ensuite, le thread A et le thread B continuent de s'exécuter, augmentant tous deux la valeur de Size.

D'accord, regardons maintenant la situation d'ArrayList. Il n'y a en fait qu'un seul élément, stocké à la position 0, mais Size est égal à 2. Il s'agit d'un "thread dangereux".

Exemple de programme :

package test;
 
importjava.util.ArrayList;
 
import java.util.List;
public class ArrayListInThread implements Runnable{
    List<String> list1 = new ArrayList<String>();// not thread safe
    publicvoid run() {
        try {
           Thread.sleep((int)(Math.random() * 2));
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        list1.add(Thread.currentThread().getName());
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadGroup group = new ThreadGroup("mygroup");
        ArrayListInThread t = new ArrayListInThread();
        for (int i = 0; i < 10000; i++) {
            Thread th = new Thread(group, t,String.valueOf(i));
            th.start();
        }
        while (group.activeCount() > 0) {
            Thread.sleep(10);
        }
        System.out.println();
        System.out.println(t.list1.size()); // it should be 10000 if thread safecollection is used.
    }
}

Comment résoudre l'insécurité des threads ?

Un : utilisez le mot-clé synchronisé, que tout le monde devrait connaître, je ne l'expliquerai donc pas

Deux : utilisez Collections.synchronizedList(); comme suit :

Supposons que le code que vous créez soit le suivant : List>data=new ArrayList>();

Ensuite, afin de résoudre ce problème de sécurité des threads, vous pouvez utiliser Collections.synchronizedList() comme ceci, par exemple :

List<Map<String,Object>> data=Collections.synchronizedList(newArrayList<Map<String,Object>>());

Rien d'autre n'a changé et la méthode utilisée est presque la même que celle d'ArrayList. vers le document API ;

Plus sur Java Pour les articles techniques, veuillez visiter la colonne Tutoriel de développement Java pour apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!