1. /*
   
2. * 单例设计模式-饿汉式和饱汉式直例设计模式
   
3. */
   
4. 
   
5. public class SingleDemo {
   
6.         String name;
   
7. 
   
8.         public String getName() {
   
9.                 return name;
   
10.         }
    
11. 
    
12.         public void setName(String name) {
    
13.                 this.name = name;
    
14.         }
    
15.    //饿汉式直例设计模式,该模式不存在线程安全问题
    
16.         /*private SingleDemo() {};
    
17.         private final static SingleDemo s = new SingleDemo();
    
18.         public static SingleDemo getSingle() {
    
19.                 return s;
    
20.         }*/
    
21.         
    
22.         //饱汉式直例设计模式
    
23.         private SingleDemo(){};
    
24.         private static SingleDemo s = null;
    
25.         public static synchronized SingleDemo getSingle(){
    
26.                 if(s==null){
    
27.                         // 若多线程时同时有多个运行到该位置，会存在线程安全问题，所以在方法上增加同步锁
    
28.                         s = new SingleDemo();
    
29.                 }
    
30.                 return s;
    
31.         }
    
32.         
    
33.         public void printInf() {
    
34.                 System.out.println("The name is" + name);
    
35.         }
    
36. 
    
37.         public static void main(String[] args) {
    
38.                 SingleDemo sd1 = SingleDemo.getSingle();
    
39.                 sd1.setName("线程一");
    
40. 
    
41.                 SingleDemo sd2 = SingleDemo.getSingle();
    
42.                 sd2.setName("线程二");
    
43.                 //无论如何打印得到的结果都是一个name值。
    
44.                 sd1.printInf();
    
45.                 sd2.printInf();
    
46.         }
    
47. }

复制代码

若多个线程都需要使用 getSingle()方法时，都会等待锁，会存在效率问题，优化后的代码如下：
注：只有修改后的代码，其他代码不变

1.         //饱汉式优化后的直例设计模式
   
2.         private SingleDemo(){};
   
3.         private static SingleDemo s = null;
   
4.         public static  SingleDemo getSingle(){
   
5.                 //双重判断的形式解决效率问题
   
6.                 if(s==null){
   
7.                         //由于是静态方法内的锁，所以锁对象是SingleDemo.class
   
8.                         synchronized(SingleDemo.class){
   
9.                                 if(s==null){
   
10.                                         // 若多线程时同时有多个运行到该位置，会存在线程安全问题，所以在方法上增加同步锁
    
11.                                         s = new SingleDemo();
    
12.                                 }
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }

复制代码

所以结论是若使用直例设计模式使用饿汉式直例设计模式

1. /*
   
2. * 单例设计模式-饿汉式和饱汉式直例设计模式
   
3. */
   
4. 
   
5. public class SingleDemo {
   
6.         String name;
   
7. 
   
8.         public String getName() {
   
9.                 return name;
   
10.         }
    
11. 
    
12.         public void setName(String name) {
    
13.                 this.name = name;
    
14.         }
    
15.    //饿汉式直例设计模式,该模式不存在线程安全问题
    
16.         /*private SingleDemo() {};
    
17.         private final static SingleDemo s = new SingleDemo();
    
18.         public static SingleDemo getSingle() {
    
19.                 return s;
    
20.         }*/
    
21.         
    
22.         //饱汉式直例设计模式
    
23.         private SingleDemo(){};
    
24.         private static SingleDemo s = null;
    
25.         public static synchronized SingleDemo getSingle(){
    
26.                 if(s==null){
    
27.                         // 若多线程时同时有多个运行到该位置，会存在线程安全问题，所以在方法上增加同步锁
    
28.                         s = new SingleDemo();
    
29.                 }
    
30.                 return s;
    
31.         }
    
32.         
    
33.         public void printInf() {
    
34.                 System.out.println("The name is" + name);
    
35.         }
    
36. 
    
37.         public static void main(String[] args) {
    
38.                 SingleDemo sd1 = SingleDemo.getSingle();
    
39.                 sd1.setName("线程一");
    
40. 
    
41.                 SingleDemo sd2 = SingleDemo.getSingle();
    
42.                 sd2.setName("线程二");
    
43.                 //无论如何打印得到的结果都是一个name值。
    
44.                 sd1.printInf();
    
45.                 sd2.printInf();
    
46.         }
    
47. }

复制代码

若多个线程都需要使用 getSingle()方法时，都会等待锁，会存在效率问题，优化后的代码如下：
注：只有修改后的代码，其他代码不变

1.         //饱汉式优化后的直例设计模式
   
2.         private SingleDemo(){};
   
3.         private static SingleDemo s = null;
   
4.         public static  SingleDemo getSingle(){
   
5.                 //双重判断的形式解决效率问题
   
6.                 if(s==null){
   
7.                         //由于是静态方法内的锁，所以锁对象是SingleDemo.class
   
8.                         synchronized(SingleDemo.class){
   
9.                                 if(s==null){
   
10.                                         // 若多线程时同时有多个运行到该位置，会存在线程安全问题，所以在方法上增加同步锁
    
11.                                         s = new SingleDemo();
    
12.                                 }
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }

复制代码

所以结论是若使用直例设计模式使用饿汉式直例设计模式