Écrivez d'abord un seul cas:
classe publique Singledemo {private static singledemo s = null; privé singledemo () {} public static singledemo getInstance () {if (s == null) {s = new SingleDemo (); } return s; }}Écrivez une classe de test:
classe publique threaddemo3 {public static void main (String [] args) {singledemo s1 = singledemo.getInstance (); Singledemo S2 = SingleDemo.getInstance (); System.out.println (S2 == S2); }}Le résultat en cours d'exécution est toujours vrai, ce qui signifie qu'il n'y a pas de problème sous un seul thread. Écrivons un multi-thread pour accéder au cas unique.
classe publique ThreadTest implémente Runnable {// Stockage des objets Singleton, l'utilisation de l'ensemble est de ne pas stocker des éléments en double set public Set <SingleDemo> singles = new HashSet <SingleDemo> (); @Override public void run () {// Get SingleDemo s = singledemo.getInstance (); // ajout de singleton singles.add (s); }}Utilisez un accès simultané multithread aux singletons:
classe publique threaddemo3 {public static void main (String [] args) {// singledemo s1 = singledemo.getInstance (); // Singledemo S2 = SingleDemo.getInstance (); // System.out.println (S2 == S2); Threadtest t = new Threadtest (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); nouveau thread (t) .start (); System.out.println (T.Singles); }}
Les résultats de l'opération sont les suivants:
[com.persagy.thread.singledemo@1bc4459, com.persagy.thread.singledemo@150bd4d]
ou
[com.persagy.thread.singledemo@12b6651]
Cela signifie qu'il y a un problème de sécurité d'accès simultané en fil et les instances obtenues peuvent ne pas être les mêmes
Comment résoudre les problèmes de sécurité des filetages?
Bien sûr, le mécanisme de verrouillage de synchronisation est utilisé.
Ce qui suit est une amélioration du singleton:
classe publique Singledemo {private static singledemo s = null; private singledemo () {} public static synchronisé singledemo getInstance () {if (s == null) {s = new singledemo ();} return s;}} Le problème de sécurité du fil a été résolu après avoir ajouté la fonction synchrone
Exécutez plusieurs fois pour obtenir la même instance, et il n'y aura pas de 2 instances.
[com.persagy.thread.singledemo@12b6651]
Cependant, dans le cas d'un accès simultané multi-thread, chaque fil doit juger la serrure chaque fois qu'il acquiert une instance, ce qui est une efficacité relativement faible. Afin d'améliorer l'efficacité, j'ai ajouté une méthode de double jugement pour résoudre le problème de l'efficacité
Le code est le suivant:
classe publique Singledemo {private static singledemo s = null; private singledemo () {} public static singledemo getInstance () {/ * Si le premier thread obtient l'objet d'instance du singleton, * lorsque le thread suivant obtient l'instance, il n'a pas besoin de saisir le bloc de code de synchronisation. * / if (s == null) {// Le verrou utilisé dans le bloc de code de synchronisation est l'objet de fichier bytecode du singleton, et ce verrou ne peut être utilisé que synchronisé (singledemo.class) {if (s == null) {s = new singledemo ();}}} return s;}}}}Cette méthode résout le problème de sécurité des filetages des personnes paresseuses et améliore l'efficacité. Cependant, dans le développement réel, plus de gens utilisent des personnes affamées. Après tout, ce code est plus compliqué et compliqué.
Ce qui précède est le contenu complet de la solution parfaite au problème de la sécurité des threads paresseux en mode de conception de cas unique que l'éditeur vous apporte. J'espère que tout le monde soutiendra Wulin.com plus ~