单例模式是一种对象创建型模式，使用单例模式，可以保证一个类只能唯一的生成一个实例化对象
GoF对单例模式的定义：保证在一个类中，只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。
在应用开发系统中，我们常常需要以下需求：
1).在多线程之间，如servlet环境，共享同一个资源或者操作同一个对象
2).在整个程序空间启用全局变量，共享资源
3).大规模系统中，为了性能的考虑，需要节省对象的创建时间等等
因为Singleton模式可以保证为一个类只生成唯一的一个实例对象，所以对于上述情况，Singleton模式就派上用场了。
单例模式实现：
1.饿汉式；
2.懒汉式；
3.双重检查
一般实现：
1 public class Person{ 2 3 priate String name; 4 5 public String getName（）{ 6 7 return name； 8 } 9 public String setName（）{ 10 11 return this.name=name； 12 } 13 14 15 }
主类：
1 public class MainClass{ 2 public static void main(String[] args){ 3 4 Person per=new Person(); 5 Person per2=new Person(); 6 //定义变量 7 per.setName("张三")； 8 per2.setName（“李四”）； 9 //通过person类生成了两个对象 10 System.out.println(per.getName()); 11 System.out.println(per2.getName()); 12 13 } 14 }
此时，在非单例模式下，定义两个对象，得到了输出结果为：
张三
李四
首先展示的是饿汉式：
1 public class Person{ 2 3 priate String name; 4 public static final Person person =new person（）；//饿汉式设置 5 // 6 public String getName（）{ 7 8 return name； 9 } 10 public String setName（）{ 11 12 return this.name=name； 13 } 14 //构造函数私有化 15 private person(){ 16 17 } 18 //构造一个全局的静态方法：因为如果不是全局的，那么需要通过对象来进行调用，如果定义成全局的静态，就可以通过类来调用 19 public static Person getPerson(){ 20 return new Person(); 21 } 22 }
此时，对于主类修改为：
1 public class MainClass{ 2 public static void main(String[] args){ 3 Person per=Person.getPerson();//不再使用new来定义对象，用类定义 4 Person per2=Person.getPerson(); 5 //定义变量 6 per.setName("张三"); 7 per2.setName("李四"); 8 //通过person类生成了两个对象 9 System.out.println(per.getName()); 10 System.out.println(per2.getName()); 11 12 } 13 }
得到的结果为：
李四
李四
懒汉式：
1 public class Person{ 2 3 priate String name; 4 private static Person person;//静态初始化默认为null 5 public String getName（）{ 6 return name； 7 } 8 public String setName（）{ 9 10 return this.name=name； 11 } 12 //构造函数私有化 13 private person(){ 14 } 15 public static Person getPerson(){ 16 //此处添加一个判断 17 if(person==null) person=new Person; 18 return person(); 19 } 20 }
结果为：
李四
李四
上述两种情形各有所长，在饿汉式中，一加载Person类就进行初始化对象，保证同一个对象
在上述懒汉式中，可以保证单线程正常单例模式
允许多线程的懒汉式单例模式：
1 public class Person{ 2 3 priate String name; 4 private static Person person;//静态初始化默认为null 5 public String getName（）{ 6 return name； 7 } 8 public String setName（）{ 9 10 return this.name=name； 11 } 12 //构造函数私有化 13 private person(){ 14 } 15 //使用一个全局的静态方法，使用同步方式 16 public static Synchrogazed Person getPerson(){ 17 //当有一个线程进来时，这个方法就被霸占了，对于进来的方法就是将执行完毕在允许其他线程进入 18 if(person==null) //第一步 19 person=new Person; // 第二步 20 return person();//第三步 21 } 22 }
双重检查：
原因：在上述的多线程代码段中，我们实现的是将整个方法都实现同步，
经过思考，我们可以发现，对于只有第一次的时候才会执行if内的内容；整个方法锁死后，接下来第二次，第三次。。。进来的都要进行判断if语句，影响执行效率
1 public class Person{ 2 3 priate String name; 4 private static Person person;//静态初始化默认为null 5 public String getName（）{ 6 return name； 7 } 8 public String setName（）{ 9 10 return this.name=name； 11 } 12 //构造函数私有化 13 private person(){ 14 } 15 //使用一个全局的静态方法 16 public static Person getPerson(){ 17 //当有一个线程进来时，这个方法就被霸占了，对于进来的方法就是将执行完毕在允许其他线程进入 18 if(person==null) { //第一步 19 Synchrogazed（Person.class）{//仅仅同步化这一部分 20 if(person==null)//这个判断语句添加的原因 当有两个线程进来时，第一个线程和第二个线程都执行完
// if(person==null)这条语句，第一个线程进入同步，第二个线程等待，当第一个线程执行完，
//return之后，第二个线程又会执行同步语句，及时第一个线程已经new了一个对象，所以为防止这个情况的发生，
//需要在同步里边再判断一次，也就是第二次判断 21 person=new Person();} 22 } // 第二步 23 return person();//第三步 24 } 25 }