【知了堂学习笔记】——设计模式之单例模式

单例模式

1.确保一个类只有一个实例，自行实例化并向系统提供这个实例
2.单例模式分类：

• 饿单例模式（类加载时实例化一个对象给自己的引用）
• 懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）

3.单例模式要素：

• a.私有构造方法
• b.私有静态引用指向自己实例
• c.以自己实例为返回值的公有静态方法

饿汉式单例：在单例类被加载时候，就实例化一个对象交给自己的引用 ;懒汉式单例：在调用取得实例方法的时候才会实例化对象

4.单例模式的优点

• 在内存中只有一个对象，节省内存中空间
• 避免繁琐的创建销毁对象，可以提高性能
• 避免对共享资源的多重占用
• 可以全局访问

5.代码实例

• 懒汉模式

package singleton;
/**
 * 懒汉式单例类，在第一次调用的时候实例化自己
 * @author Administrator
 *  */
public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){

    }
    //静态示例方法
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

• 优点：
  避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。

• 缺点：
  懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。

• 饿汉式单例

package singleton;
/**
 * 饿汉式单例，在类初始化时，已经自行实例化
 * @author Administrator
 *
 */
public class Singleton2 {
    private static final  Singleton2 singleton2 = new Singleton2();
    private Singleton2(){

    }

    //静态工厂方法
    public static Singleton2 getInstance(){
        return singleton2;
    }
}

饿汉模式的优缺点：

• 优点：
  1.线程安全
  2.在类加载的同时已经创建好一个静态对象，调用时反应速度快

• 缺点
  资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化

6.关于懒汉式单例线程不安全解决方案

• 在方法上加上同步

public static synchronized Singleton getInstance(){

    }

在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的

• 双重锁定

    public static TestSingleton getInstance(){
        if(instance == null){
            synchronized (TestSingleton.class){ 
                if(instance == null){
                    instance = new TestSingleton();
                }

            }
        }
        return instance;
    }

在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

• 静态内部类

class Test {
        private Test() {
        }

        private static class SingletonHelp {
                static Test instance = new Test();
        }

        public static Test getInstance() {
                return SingletonHelp.instance;
        }
}

利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

7.应用

• 静态内部类测试

package thread_2;
/**
 * 懒汉模式--静态内部类
 * @author Administrator
 *
 */
public class TestSingleton {
    String name = null;
    private TestSingleton(){

    }
    private static class SingletonHelp{
        static TestSingleton instance = new TestSingleton();
    }

    public static TestSingleton getInstance(){
        return SingletonHelp.instance;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void printInfo(){
        System.out.println("this name is "+name);
    }
}

• 测试

package thread_2;

public class Tmain {
    public static void main(String[] args) {
        TestSingleton ts1 = TestSingleton.getInstance();
        ts1.setName("Json");
        TestSingleton ts2 = TestSingleton.getInstance();
        ts2.setName("Tom");

        ts1.printInfo();
        ts2.printInfo();

        if(ts1 == ts2){
            System.out.println("创建的是同一个实例");

        }else{
            System.out.println("创建的不是同一个实例");
        }
    }
}

• 运行结果

this name is Tom
this name is Tom
创建的是同一个实例

总结：
一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测

请关注“知了堂学习社区”，地址：http://www.zhiliaotang.com/portal.php