单例模式的第一个版本，一般都是采用“饿汉式”的模式，即在类加载进来的时候就实例化对象，但是这种方式比较消耗计算机资源
具体如下demo：
package cn.design.singleton;
public class Singleton {
?private String name;
?//在类被加载进入内存的时候就创建单一的对象
?public static final Singleton instance=new Singleton();
?private Singleton() {//构造方法私有化
?}
?public void setName(String name) {
? this.name = name;
?}
?public String getName() {
? return name;
?}
? ?
?//提供一个全局的静态方法
?public static Singleton getInstance() {
?
? return instance;
?}
}
如是出现了单例的第二个版本：“懒汉式”，在单线程下工作的还不错，但在多线程下存在安全性问题，具体如下demo：
package cn.design.singleton;
public class Singleton {
?private String name;
?private static Singleton instance;//对单例本身引用的名称
?private Singleton() {//构造方法私有化
?}
?public void setName(String name) {
? this.name = name;
?}
?public String getName() {
? return name;
?}
? ?
?//提供一个全局的静态方法
?public static Singleton getInstance() {
? if (null == instance) {
? ?instance = new Singleton();
? }
? return instance;
?}
}
考虑到在多线程下，懒汉模式不适用，如是采用了对方法进行同步的方式，出现了第三个版本的单例，具体如下：
package cn.design.singleton;
public class Singleton {
?private String name;
?private static Singleton instance;//对单例本身引用的名称
?private Singleton() {//构造方法私有化
?}
?public void setName(String name) {
? this.name = name;
?}
?public String getName() {
? return name;
?}
? ?
?//提供一个全局的静态方法
?public static synchronized Singleton getInstance() {
? if (null == instance) {
? ? ? instance = new Singleton();
? }// if
? return instance;
?}
}
但第三个版本的singleton比较浪费资源，每次都要进行同步检查，事实上第一次进行同步检查就可以了，如是出现了第四个比较成熟的单例模式，如下：
package cn.design.singleton;
public class Singleton {
?private String name;
?private static Singleton instance;//对单例本身引用的名称
?private Singleton() {//构造方法私有化
?}
?public void setName(String name) {
? this.name = name;
?}
?public String getName() {
? return name;
?}
? ?
?//提供一个全局的静态方法
?public static Singleton getInstance() {
? if (null == instance) {
? ?synchronized (Singleton.class) {
? ? instance = new Singleton();
? ?}
? }// if
? return instance;
?}
}
测试代码如下：
package cn.design.singleton;
public class TestSingleton {
?public static void main(String[] args) {
?
? //实例化对象
? Singleton singleton1=Singleton.getInstance();
? Singleton singleton2=Singleton.getInstance();
?
? //赋值
? singleton1.setName("Jon");
? singleton2.setName("Linda");
?
? System.out.println(singleton1.getName());
? System.out.println(singleton2.getName());
?}
}
输出结果为:
Linda
Linda
单例的优点：实例化的时候，只需要调用一个单一的方法即可实现唯一的实例，有利于节约资源
缺点：首先很难实现序列化，其次由于单例采用静态方法，无法在继承结构中使用