单例模式

 GoF对单例模式(Singleton Pattern)的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。 

笔者在这里以MM的男朋友GG为例进行单例模式的说明。

GG单例模式的第一个版本，采用的是“饿汉式”，也就是当类加载进来的就立即实例化GG对象，但是这种方式比较的消耗计算机资源。具体实现代码如下：

package com.diermeng.designPattern.Singleton;

/*

 * GG单例模式的第一个版本 为“饿汉式”

 */

public class GGVersionOne {

    //在类被加载进入内存的时候就创建单一的GG对象

    public static final GGVersionOne gGVersionOne = new GGVersionOne();

    //名称属性

    private String name;

   

   

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

   

    //构造函数私有化

    private GGVersionOne() {

    }

   

    //提供一个全局的静态方法

    public static GGVersionOne getGG() {

        return gGVersionOne;

    }

}

 

GG单例模式的第二个版本：“懒汉式”，在单线程下能够非常好的工作，但是在多线程下存在线程安全问题，具体代码如下：

package com.diermeng.designPattern.Singleton;

/*

 * GG单例模式的第二个版本 采用“懒汉式” 在需要使用的时候才实例化GG

 */

public class GGVersionTwo {

    //GG的姓名

    private String name;

    //对单例本身引用的名称

    private static GGVersionTwo gGVersionTwo;

   

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

   

    //构造函数私有化

    private GGVersionTwo() {

    }

   

    //提供一个全局的静态方法

    public static GGVersionTwo getGG() {

        if(gGVersionTwo == null) {

            gGVersionTwo = new GGVersionTwo();

        }

        return gGVersionTwo;

    }

}

 

GG单例模式的第三个版本，为解决多线程问题，采用了对函数进行同步的方式，但是比较浪费资源，因为每次都要进行同步检查，而实际中真正需要检查只是第一次实例化的时候，具体代码如下所示：

package com.diermeng.designPattern.Singleton;

/*

 * GG单例模式的第三个版本 对函数进行同步

 */

public class GGVersionThree {

    //GG的姓名

    private String name;

    //对单例本身引用的名称

    private static GGVersionThree gGVersionThree;

   

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

   

    //构造函数私有化

    private GGVersionThree() {

    }

   

    //提供一个全局的静态方法，使用同步方法

    public static synchronized GGVersionThree getGG() {

        if(gGVersionThree == null) {

            gGVersionThree = new GGVersionThree();

        }

        return gGVersionThree;

    }

}

 

GG单例模式第四个版本，既解决了“懒汉式的”多线程问题，又解决了资源浪费的现象，看上去是一种不错的选择，具体代码如下所示：

package com.diermeng.designPattern.Singleton;

/*

 * GG单例模式的第四个版本，既解决了“懒汉式的”多线程问题，又解决了资源浪费的现象，看上去是一种不错的选择

 */

public class GGVersionFour {

    //GG的姓名

    private String name;

    //对单例本身引用的名称

    private static GGVersionFour gGVersionFour;

   

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

   

    //构造函数私有化

    private GGVersionFour() {

    }

   

    //提供一个全局的静态方法

    public static GGVersionFour getGG() {

        if(gGVersionFour == null) {

            synchronized (GGVersionFour.class) {

                if(gGVersionFour == null) {

                    gGVersionFour = new GGVersionFour();

                }

            }

           

        }

        return gGVersionFour;

    }

}

 

 

      

最后我们建立测试客户端测试一下版本四：

package com.diermeng.designPattern.Singleton.client;

import com.diermeng.designPattern.Singleton.GGVersionFour;

 

/*

 * 测试客户端

 */

public class SingletonTest {

    public static void main(String[] args) {

        //实例化

        GGVersionFour gG1 = GGVersionFour.getGG();

        GGVersionFour gG2 = GGVersionFour.getGG();

        //设值

        gG1.setName("GGAlias");

        gG2.setName("GG");

       

        System.out.println(gG1.getName());

        System.out.println(gG2.getName());

       

       

    }

}

 

 

输出的结果如下：

GG

GG