Primeiro, escreva um único caso:
classe pública SingledEMo {private static singledemo s = null; Private SingleDemo () {} public static SingleDemo getInstance () {if (s == null) {s = new SingleDemo (); } retornar s; }}Escreva uma aula de teste:
classe pública threadDemo3 {public static void main (string [] args) {SingleDemo s1 = SingleDemo.getInstance (); SingleDemo S2 = SingleDemo.getInstance (); System.out.println (S2 == S2); }}O resultado em execução é sempre verdadeiro, o que significa que não há problema em um único thread. Vamos escrever um multi-thread para acessar o caso único.
classe pública threadtest implementa Runnable {// Armazenando objetos singleton, usando o conjunto é não armazenar elementos duplicados set public <SetleDemo> singles = new Hashset <SingleDemo> (); @Override public void run () {// Get SingleDemo s = SingleDemo.getInstance (); // adicionando singleton singles.add (s); }}Use acesso simultâneo multithread a singletons:
classe pública threadDemo3 {public static void main (string [] args) {// SingleDemo S1 = SingleDemo.getInstance (); // SingleDemo S2 = SingleDemo.getInstance (); // System.out.println (S2 == S2); ThreadTest t = new ThreadTest (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); novo thread (t) .start (); System.out.println (t.singles); }}
Os resultados da operação são os seguintes:
[com.persagy.thread.singledemo@1bc4459, com.persagy.thread.singledemo@150bd4d]
ou
[com.persagy.thread.singledemo@12b6651]
Isso significa que existe um problema de segurança de acesso simultâneo encadeado, e as instâncias obtidas podem não ser as mesmas
Como resolver problemas de segurança de threads?
Obviamente, o mecanismo de bloqueio de sincronização é usado.
A seguir, é apresentada uma melhoria para o singleton:
classe pública SingleDemo {private static singledemo s = null; privado singledemo () {} public static sincronizado SingleDemo getInstance () {if (s == null) {s = new SingleDemo ();} retorna s;}}}} O problema de segurança do fio foi resolvido após a adição da função síncrona
Execute várias vezes para obter a mesma instância e não haverá 2 instâncias.
[com.persagy.thread.singledemo@12b6651]
No entanto, no caso de acesso simultâneo com vários threads, cada encadeamento deve julgar a trava toda vez que adquire uma instância, que é uma eficiência relativamente baixa. Para melhorar a eficiência, adicionei um método de julgamento duplo para resolver o problema de eficiência
O código é o seguinte:
classe pública Singledemo {private static singledemo s = null; privado singledemo () {} public static singleledemo getInstance () {/ * se o primeiro thread obtiver o objeto de instância do singleton, * quando o encadeamento subsequente obtém a instância, não precisará entrar no bloco de código de sincronização. */if(s == null){//The lock used in the synchronization code block is the bytecode file object of the singleton, and this lock can only be used synchronized(SingleDemo.class){if(s == null){s = new SingleDemo();}}} return s;}}}Este método resolve o problema de segurança de roscas das pessoas preguiçosas e melhora a eficiência. No entanto, no desenvolvimento real, mais pessoas usam pessoas famintas. Afinal, esse código é mais complicado e complicado.
O exposto acima é o conteúdo completo da solução perfeita para o problema da segurança da linha preguiçosa no modo de design de casos únicos que o editor traz para você. Espero que todos apoiem mais wulin.com ~