四，设计模式-单例模式

简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。
单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”


单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

分类

单例模式分为懒汉式和饿汉式，因为懒汉式在多线程中属于不安全的类型，所以在懒汉式的基础上添加了同步锁，经过两布判断达到高性能的安全模式（改造懒汉式）

饿汉式

说明

1. 饿汉式单例类.在类初始化的时候就进行初始化。
2. 私有的默认构造子。
3. 提供静态工厂方法共外部调用获取实例。

代码示例

/**
 * 饿汉式（单例设计模式）
 */
public class Singleton2 {
    private static Singleton2 singleton2=new Singleton2();
    private String name;

    //私有化默认构造器
    private Singleton2(){}

    //提供静态的方法共调用

    public static Singleton2 getInstance(){
        return singleton2;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 测试入口
 */
public class MainClass {

    public static void main(String[] args){

        Singleton2 singleton1=Singleton2.getInstance();
        Singleton2 singleton2=Singleton2.getInstance();
        singleton1.setName("Bob");
        System.out.println(singleton1.getName());
        System.out.println(singleton2.getName());
        singleton2.setName("Tom");
        System.out.println(singleton1.getName());
        System.out.println(singleton2.getName());

    }
}

上面的例子中我们看到第一给name赋值的打印出来两个相同的结果，我们为singleton2中的name赋值，结果第一个name值也已经改变，从而说明这两个对象是统一个实例。

懒汉式

//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1{
//私有的默认构造子
private Singleton1(){}
//已经自行实例化
private static final Singleton1 single=new Singleton1();
//静态工厂方法
public static Singleton1 getInstance(){
return single;
}
}

说明

1. 懒汉式单例类.在第一次调用的时候实例化。
2. 私有的默认构造子。
3. 提供静态工厂方法共外部调用获取实例。

代码示例

/**
 * 懒汉式（单例设计模式）
 */
public class Singleton1 {
    private static Singleton1 singleton1;
    private String name;

    //私有化默认构造器
    private Singleton1(){}

    //提供静态的方法共调用

    public static  Singleton1 getInstance(){
        if (singleton1==null){
            singleton1=new Singleton1();
        }
        return singleton1;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 测试入口
 */
public class MainClass {

    public static void main(String[] args) {
        Singleton1 singleton1=Singleton1.getInstance();
        Singleton1 singleton2=Singleton1.getInstance();
        singleton1.setName("Bob");
        System.out.println(singleton1.getName());
        System.out.println(singleton2.getName());
        singleton2.setName("Tom");
        System.out.println(singleton1.getName());
        System.out.println(singleton2.getName());

    }
}

运行结果：

上面的例子中我们看到打印结果没有任何变化，从而说明这两个对象也是统一个实例。

改造懒汉式

说明

在懒汉式中我们很轻易的发现这是 一个线程不安全的，在多线程开发中，尽量使用饿汉式，如果非要使用懒汉式这需要使用synchronized 关键字进行枷锁，枷锁的地方也分多种如下列代码。

代 码示例

第一种直接方法上添加：

   //提供静态的方法共调用

    public static synchronized Singleton3 getInstance(){
        if (singleton3==null){
            singleton3=new Singleton3();
        }
        return singleton3;
    }

虽然也能够解决问题但是这种方式效率很低。

第二种：

  //提供静态的方法共调用

    public static  Singleton3 getInstance(){
        if (singleton3==null){
            synchronized (Singleton3.class){
                if (singleton3==null){
                    singleton3=new Singleton3();
                }
            }
        }
        return singleton3;
    }

经过这种改造懒汉式变了线程安全的模式，在多线程编程中，可以使用这种方式进行编程。