单例模式（Singleton）,保证一个类仅有一个实例，并提供一个访问他的全局访问点，通常我们可以让一个全局变量使得一个对象被访问，但他不能防止实例化多个对象。一个最好的办法就是，让类自身负责保存他的唯一实例。这个类可以保证没有其他实例可以被创建，并且他可以提供一个访问该实例的方法。
      所有类都有构造方法，不编码则系统默认生成空的构造方法，如重写构造方法，则默认的构造方法就会失效。

1. public class Singleton {
   
2.     /**
   
3.      *利用一个静态变量记录Singleton类的唯一实例。如果没有“static”修饰，下面的
   
4.      *getSingleton（）方法不能引用非静态变量singleton。“volatile”修饰符
   
5.      *保证了内存可见，即如果该变量有变化（这里的变化就是被实例化），
   
6.      *多个线程能及时看到singleton变量的变化。
   
7.      */
   
8.     private volatile static Singleton singleton;
   
9.     //构造私有的构造函数，只有在Singleton类内才可以调用
   
10.     private Singleton() {}
    
11.     //getSingleton()方法提供了一个全局访问点
    
12.     public static Singleton getSingleton() {
    
13.         //利用双重锁，首先检查实例是否已经创建，如果没有创建才进行同步，
    
14.         //如果创建过就直接返回，不需要加锁。
    
15.         //如果对整个方法使用synchronized加锁则会造成效率降低。
    
16.         if (singleton == null) {
    
17.             synchronized (Singleton.class) {
    
18.                 /**
    
19.                  *如果为空，就利用私有的构造函数产生一个Singleton实例并把它赋值到singleton
    
20.                  *静态变量中
    
21.                                  */               
    
22.                 if (singleton == null) {
    
23.                     singleton = new Singleton();
    
24.                 }
    
25.             }
    
26.         }
    
27.         //如果不为空，就表示之前已经创建过实例，并将singleton当做返回值
    
28.         return singleton;
    
29.     }
    
30. 
    
31.     public void add() {
    
32.         System.out.println("add");
    
33.     }
    
34. 
    
35.     public static void main(String[] args) {
    
36.         //创建实例
    
37.         Singleton sing = Singleton.getSingleton();
    
38.         Singleton sing2 = Singleton.getSingleton();
    
39.         sing.add();
    
40.         sing2.add();
    
41.         //用“==”判断实例是否指向相同对象
    
42.         System.out.println("sing == sing2: " + (sing == sing2));
    
43.     }
    
44. }
    
45. 
    
46. 运行结果：
    
47. add
    
48. add
    
49. sing == sing2: true     //通过结果可以看出两个引用指向同一对象

复制代码

这是在同一个类中创建main()方法，如果在另外一个类中创建

1. public class Singleton {
   
2.     private volatile static Singleton singleton;
   
3.     private Singleton() {}
   
4. 
   
5.     public static Singleton getSingleton() {
   
6.         if (singleton == null) {
   
7.             synchronized (Singleton.class) {
   
8.                 if (singleton == null) {
   
9.                     singleton = new Singleton();
   
10.                 }
    
11.             }
    
12.         }
    
13.         return singleton;
    
14.     }
    
15. 
    
16.     public void add() {
    
17.         System.out.println("add");
    
18.     }
    
19. }
    
20. 
    
21. class MainTest {
    
22.     public static void main(String[] args) {
    
23.             /**
    
24.             *语句不能通过编译，就保证了类的单一实例。
    
25.             */
    
26.             //Singleton test3 = Singleton.singleton;  
    
27.             //getSingleton()方法时静态的，就可以在代码的任何地方使用Singleton.getSingleton（）
    
28.         Singleton test1 = Singleton.getSingleton();
    
29.         Singleton test2 = Singleton.getSingleton();
    
30.         //Singleton test4 = Singleton.singleton;
    
31.         test1.add();
    
32.         //test3.add();
    
33.         System.out.println("test1 == test2: " + (test1 == test2));
    
34.         //System.out.println("test3 == test4: " + (test3 == test4));
    
35.         //System.out.println("test1 == test3: " + (test1 == test3));
    
36.         //System.out.println("test1 == test4: " + (test1 == test4));
    
37.     }
    
38. }
    
39. 运行结果：
    
40. E:\test-git\Thread>javac Singleton.java
    
41. //编译时会编译出两个class文件，因为main方法在MainTest.class中，所有运行时用java MainTest
    
42. E:\test-git\Thread>java MainTest
    
43. add
    
44. test1 == test2: true

复制代码

“private volatile static Singleton singleton”中的private修饰符如果该为public就不能保证类的唯一实例。

1. public class Singleton {
   
2.     public volatile static Singleton singleton;
   
3.     private Singleton() {}
   
4. 
   
5.     public static Singleton getSingleton() {
   
6.         if (singleton == null) {
   
7.             synchronized (Singleton.class) {
   
8.                 if (singleton == null) {
   
9.                     singleton = new Singleton();
   
10.                 }
    
11.             }
    
12.         }
    
13.         return singleton;
    
14.     }
    
15. 
    
16.     public void add() {
    
17.         System.out.println("add");
    
18.     }
    
19. }
    
20. 
    
21. class MainTest {
    
22.     public static void main(String[] args) {
    
23.             Singleton test3 = Singleton.singleton;  
    
24.             //getSingleton()方法时静态的，就可以在代码的任何地方使用Singleton.getSingleton（）
    
25.         Singleton test1 = Singleton.getSingleton();
    
26.         Singleton test2 = Singleton.getSingleton();
    
27.         Singleton test4 = Singleton.singleton;
    
28.         test1.add();
    
29.         //test3.add();   如果加上运行时会报异常，引用了空指针
    
30.         System.out.println("test1 == test2: " + (test1 == test2));
    
31.         System.out.println("test3 == test4: " + (test3 == test4));
    
32.         System.out.println("test1 == test3: " + (test1 == test3));
    
33.         System.out.println("test1 == test4: " + (test1 == test4));
    
34.     }
    
35. }
    
36. 
    
37. 运行结果：
    
38. add
    
39. test1 == test2: true   // 从这看出test1和test2是指向同一个对象的
    
40. test3 == test4: false   // 从下面三句可以看出test3和test1、test2、test4的引用不同。
    
41. test1 == test3: false   //从“test3.add();”看出test3为null。
    
42. test1 == test4: true
    

复制代码

PS：我朋友说单例模式这才刚刚入门，还有两点更高级的东西，等进了水平高了再教。

写得好，谢谢分享，收藏一下

个人觉得单例模板和框架有点类似

有点复杂

已收藏，感谢分享