Java设计模式

1.单例模式

（1）懒汉式

 1 public class LazySingleton {
 2     /**
 3      * 保证 instance 在所有线程中同步
 4      */
 5     private static volatile LazySingleton lazySingleton = null;
 6     /**
 7      * 避免类在外部被实例化
 8      */
 9     private LazySingleton(){}
10 
11     public static synchronized LazySingleton getLazySingleton() {
12         if (lazySingleton == null) {         
14             lazySingleton= new LazySingleton();
15         }
16 
17         return lazySingleton;
18     }
19 }
20 
21 
22 public class SingletonTest {
23     public static void main(String[] args) {
24         LazySingleton lazySingleton = LazySingleton.getLazySingleton();
25         System.out.println("lazySingleton = " + lazySingleton);
26         LazySingleton lazySingleton1 = LazySingleton.getLazySingleton();
27         System.out.println("lazySingleton1 = " + lazySingleton1);
28         if (lazySingleton == lazySingleton1) {
29             System.out.println("懒汉式单例模式实现了");
30         }
31 
32         System.out.println("===========================");
33         Runnable runnable = () -> {
34             LazySingleton lazySingleton2 = LazySingleton.getLazySingleton();
35             System.out.println("lazySingleton2 = " + lazySingleton2);
36         };
37         runnable.run();
38     }
39 }
40 
41 输出：
42 lazySingleton = test.model.LazySingleton@1540e19d
43 lazySingleton1 = test.model.LazySingleton@1540e19d
44 懒汉式单例模式实现了
45 ===========================
46 lazySingleton2 = test.model.LazySingleton@1540e19d

 

注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

（2）饿汉式

 1 public class HungrySingleton {
 2     private static final HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();
 3 
 4     private HungrySingleton() {
 5 
 6     }
 7 
 8     public static HungrySingleton getHungrySingleton() {
 9         return HUNGRY_SINGLETON;
10     }
11 }
12 
13 
14         HungrySingleton hungrySingleton = HungrySingleton.getHungrySingleton();
15         System.out.println("hungrySingleton = " + hungrySingleton);
16         HungrySingleton hungrySingleton1 = HungrySingleton.getHungrySingleton();
17         System.out.println("hungrySingleton = " + hungrySingleton1);
18         if (hungrySingleton == hungrySingleton1) {
19             System.out.println("饿汉式单例模式实现了");
20         }
21 
22         System.out.println("===========================");
23         Runnable runnable1 = () -> {
24             HungrySingleton hungrySingleton2 = HungrySingleton.getHungrySingleton();
25             System.out.println("hungrySingleton = " + hungrySingleton2);
26         };
27         runnable1.run();  
28 
29 
30 输出：
31 hungrySingleton = test.model.HungrySingleton@682a0b20
32 hungrySingleton = test.model.HungrySingleton@682a0b20
33 饿汉式单例模式实现了
34 ===========================
35 hungrySingleton = test.model.HungrySingleton@682a0b20

 

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

 

posted @ 2019-07-19 11:27  小星河  阅读(188)  评论(0)    收藏  举报