单例模式的创建
单例模式创建方式：
一、创建一个类
二、new该类的实例
三、私有化无参构造，防止调用该类
四、静态方法返回该类的实例
一、饿汉式创建单例模式，线程安全，但是存在浪费内存的问题
public class SingleObject {
//创建 SingleObject 的一个对象
private static SingleObject instance = new SingleObject();
//让构造函数为 private，这样该类就不会被实例化
private SingleObject(){}
//获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}
}
二、懒汉式创建单例，即需要该类的对象时才创建，而不是一开始就创建好，同时每次都返回同一个引用对象，而不是重新创建对象，但是存在线程不安全问题
1 public class SingleObj {
2
3 //声明本类的私有引用
4 private static SingleObj singleObj;
5
6 //私有化构造函数，不能通过new的方式创建本类
7 public SingleObj() {}
8
9 //创建静态方法返回本类的实例
10 public static SingleObj getInstance(){
11 //判断本类的实例对象是否已经创建
12 if(singleObj == null){
13 //如果之前没有创建，则创建一个实例对象
14 singleObj = new SingleObj();
15 }16 //代码运行到这，表明本类的对象已经创建好，最后返回本类的引用
17 return singleObj;
18 19 }
20 }
三、解决懒汉式线程不安全的情况，使用双检锁方式，将创建本类对象的代码加锁，再次判断，解决了线程不安全的问题
1 public class SingleObj2 {
2
3 //声明本类的私有引用
4 private static SingleObj2 singleObj2;
5
6 //私有化构造函数，不能通过new的方式创建本类
7 public SingleObj2() {}
8
9 //创建静态方法返回本类的实例
10 public static SingleObj2 getInstance(){
11 //判断本类的实例对象是否已经创建
12 if(singleObj2 == null){
13 //当发现没有本类对象时，将创建本类对象的操作进行加锁，防止线程不安全的情况发生
14 synchronized(SingleObj2.class){
15 //再次判断本类的引用是否为空
16 if(singleObj2 == null){
17 //创建本类的对象
18 singleObj2 = new SingleObj2();
19 }
20 }
21 }
22 //如果发现已经创建好了，则直接返回本类的引用
23 return singleObj2;
24 }
25 }
四、静态内部类的创建方式，效果类似于双检锁，但是只适合静态域
1 public class SingleObj3 {
2
3 //定义静态内部类
4 private static class Singleton{
5 private static final SingleObj3 INSTANCE = new SingleObj3();
6 }
7
8 //私有化构造函数
9 private SingleObj3() {}
10
11 //静态final类获取静态内部类创建的实例对象
12 public static final SingleObj3 getInstance(){
13 return Singleton.INSTANCE;
14 }
15 }
