Explication détaillée de la sécurité des threads et de la sécurité des non-threads en Java
- 黄舟original
- 2017-10-12 10:09:391754parcourir
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.
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.
Non thread-safe ! = Non sécurisé
Mise en œuvre de la sécurité des threads
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. 9963727 9973178 9999577 9987650 9988734 9988665 9987820 9990847 9992305 9972233Modifiez 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. 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!