Explication détaillée de la sécurité des threads et de la sécurité des non-threads en Java

Cet article présente principalement l'analyse de la sécurité des threads Java et de la sécurité des non-threads, impliquant la simulation de phénomènes de sécurité non-thread et la mise en œuvre de la sécurité des threads. Les amis dans le besoin peuvent s'y référer et échanger et apprendre ensemble.

Quelle est la différence entre ArrayList et Vector ? Quelle est la différence entre HashMap et HashTable ? Quelle est la différence entre StringBuilder et StringBuffer ? Ce sont des questions de base courantes dans les entretiens Java. Face à une telle question, la réponse est : ArrayList n'est pas thread-safe, Vector est thread-safe ; HashMap est non-thread-safe, HashTable est thread-safe ; StringBuilder est non-thread-safe et StringBuffer est thread-safe. Parce que c'est ce qui a été écrit dans les "Questions complètes d'entretien Java" que je viens de mémoriser hier soir. À ce stade, si vous continuez à demander : qu’est-ce que la sécurité des threads ? Quelle est la différence entre thread-safe et non-thread-safe ? Dans quelles circonstances sont-ils utilisés ? Une telle série de questions a jailli...

Simulation de phénomènes non thread-safe

ArrayList et Vector sont utilisés ici Le lecteur va expliquer.

Le code suivant crée une nouvelle ArrayList non thread-safe dans le thread principal, puis ouvre 1000 threads pour ajouter des éléments à cette ArrayList, chaque thread ajoute 100 éléments, et ainsi de suite pour tous les threads après exécution, quelle doit être la taille de cette ArrayList ? Cela devrait être 100 000 ?

public class Main 
{ 
  public static void main(String[] args) 
  { 
    // 进行10次测试 
    for(int i = 0; i < 10; i++) 
    { 
      test(); 
    } 
  } 
  public static void test() 
  { 
    // 用来测试的List 
    List<Object> list = new ArrayList<Object>(); 
    // 线程数量(1000) 
    int threadCount = 1000; 
    // 用来让主线程等待threadCount个子线程执行完毕 
    CountDownLatch countDownLatch = new CountDownLatch(threadCount); 
    // 启动threadCount个子线程 
    for(int i = 0; i < threadCount; i++) 
    { 
      Thread thread = new Thread(new MyThread(list, countDownLatch)); 
      thread.start(); 
    } 
    try 
    { 
      // 主线程等待所有子线程执行完成，再向下执行 
      countDownLatch.await(); 
    } 
    catch (InterruptedException e) 
    { 
      e.printStackTrace(); 
    } 
    // List的size 
    System.out.println(list.size()); 
  } 
} 
class MyThread implements Runnable 
{ 
  private List<Object> list; 
  private CountDownLatch countDownLatch; 
  public MyThread(List<Object> list, CountDownLatch countDownLatch) 
  { 
    this.list = list; 
    this.countDownLatch = countDownLatch; 
  } 
  public void run() 
  { 
    // 每个线程向List中添加100个元素 
    for(int i = 0; i < 100; i++) 
    { 
      list.add(new Object()); 
    } 
    // 完成一个子线程 
    countDownLatch.countDown(); 
  } 
}

Ce qui précède est testé 10 fois (pourquoi tester 10 fois ? Parce que la sécurité sans fil ne pose pas de problèmes à chaque fois).

Résultats de sortie :

99946
100000
100000
100000
99998
99959
100000
99975
100000
99996

Les résultats de sortie ci-dessus montrent que tous les résultats de test ne sont pas 100 000, il y en a après plusieurs tests, la taille de l'ArrayList était inférieure à 100 000 et une IndexOutOfBoundsException était même levée de temps en temps. (Si ce phénomène ne se produit pas, vous pouvez essayer plusieurs fois)

Il s'agit d'un problème causé par la sécurité non-thread. Si le code ci-dessus est utilisé dans un environnement de production, il y aura des dangers et des bugs cachés.

Utilisez ensuite le vecteur thread-safe pour tester. Modifiez le code ci-dessus à un seul endroit, dans la méthode test(),

<. 🎜>

List<Object> list = new ArrayList<Object>();

Changez pour

List<Object> list = new Vector<Object>();

et exécutez à nouveau le programme.

Résultat de sortie :

100000
100000
100000
100000
100000
100000
100000
100000
100000
100000

Après avoir exécuté quelques fois de plus, j'ai trouvé qu'ils étaient tous 100 000 , sans aucun problème. Étant donné que Vector est thread-safe, il n'y aura aucun problème lorsque plusieurs threads opèrent sur le même objet Vector.

Essayez de passer à LinkedList. Des problèmes similaires avec ArrayList se produiront également, car LinkedList n'est pas non plus thread-safe.

Comment choisir entre les deux

La sécurité non-thread signifie que des problèmes peuvent survenir lorsque plusieurs threads exploitent le même objet. La sécurité des threads signifie qu’il n’y aura aucun problème lorsque plusieurs threads exploiteront le même objet.

La sécurité des threads doit utiliser de nombreux mots-clés synchronisés pour le contrôle de la synchronisation, cela entraînera donc inévitablement une réduction des performances.

Ainsi, lorsque vous l'utilisez, si plusieurs threads exploitent le même objet, utilisez le vecteur thread-safe, sinon utilisez ArrayList, plus efficace.

Non thread-safe ! = Non sécurisé

Quelqu'un a une vue incorrecte lors de l'utilisation : I Le programme est multithread et ne peut pas utiliser ArrayList. Il est sûr d'utiliser Vector.

La sécurité non-thread ne signifie pas qu'elle ne peut pas être utilisée dans un environnement multi-thread. Notez ce que j'ai dit ci-dessus : plusieurs threads opèrent sur le même objet. Notez qu'il s'agit du même objet. Par exemple, la simulation supérieure est une nouvelle ArrayList dans le thread principal, puis plusieurs threads exploitent le même objet ArrayList.

S'il s'agit d'une nouvelle ArrayList dans chaque thread et que cette ArrayList n'est utilisée que dans ce fil, alors il n'y a certainement aucun problème.

Mise en œuvre de la sécurité des threads

La sécurité des threads est obtenue grâce au contrôle de synchronisation des threads, qui est le mot-clé synchronisé .

Ici, j'ai utilisé du code pour implémenter un compteur non thread-safe et un compteur thread-safe Counter, et j'ai effectué des tests multi-thread sur eux.

Compteur non thread-safe :

public class Main 
{ 
  public static void main(String[] args) 
  { 
    // 进行10次测试 
    for(int i = 0; i < 10; i++) 
    { 
      test(); 
    } 
  } 
  public static void test() 
  { 
    // 计数器 
    Counter counter = new Counter(); 
    // 线程数量(1000) 
    int threadCount = 1000; 
    // 用来让主线程等待threadCount个子线程执行完毕 
    CountDownLatch countDownLatch = new CountDownLatch(threadCount); 
    // 启动threadCount个子线程 
    for(int i = 0; i < threadCount; i++) 
    { 
      Thread thread = new Thread(new MyThread(counter, countDownLatch)); 
      thread.start(); 
    } 
    try 
    { 
      // 主线程等待所有子线程执行完成，再向下执行 
      countDownLatch.await(); 
    } 
    catch (InterruptedException e) 
    { 
      e.printStackTrace(); 
    } 
    // 计数器的值 
    System.out.println(counter.getCount()); 
  } 
} 
class MyThread implements Runnable 
{ 
  private Counter counter; 
  private CountDownLatch countDownLatch; 
  public MyThread(Counter counter, CountDownLatch countDownLatch) 
  { 
    this.counter = counter; 
    this.countDownLatch = countDownLatch; 
  } 
  public void run() 
  { 
    // 每个线程向Counter中进行10000次累加 
    for(int i = 0; i < 10000; i++) 
    { 
      counter.addCount(); 
    } 
    // 完成一个子线程 
    countDownLatch.countDown(); 
  } 
} 
class Counter 
{ 
  private int count = 0; 
  public int getCount() 
  { 
    return count; 
  } 
  public void addCount() 
  { 
    count++; 
  } 
}

Dans le code de test ci-dessus, 1000 threads sont ouverts, chaque thread Accumulez le compteur 10 000 fois et le résultat final devrait être de 10 000 000.

Cependant, le compteur dans le code ci-dessus n'est pas contrôlé de manière synchrone, il n'est donc pas thread-safe.

Résultat de sortie :

9963727
9973178
9999577
9987650
9988734
9988665
9987820
9990847
9992305
9972233

Modifiez légèrement le compteur en un compteur thread-safe :

class Counter 
{ 
  private int count = 0; 
  public int getCount() 
  { 
    return count; 
  } 
  public synchronized void addCount() 
  { 
    count++; 
  } 
}

Ce qui précède ajoute simplement un contrôle de synchronisation synchronisé à la méthode addCount(), et il devient un compteur thread-safe. Exécutez à nouveau le programme.

Résultat de sortie :

10000000
10000000
10000000
10000000
10000000
10000000
10000000
10000000
10000000
10000000

Résumé

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!