java设计模式学习-单例模式

java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”单例模式可以保证一个应用中有且只有一个实例，避免了资源的浪费和多个实例多次调用导致出错。

　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

　　所以相应的，我们用代码实现为：

　　1.私有化该类的构造函数

　　2.通过new在本类中创建一个本类对象

　　3.提供一个共有的方法，给给类创建的对象返回

　1.　饿汉式写法

public class Singleton { //饿汉式

     int a=1;

     private Singleton(){};

     private static Singleton instance = new Singleton();

     public static Singleton getInstance(){

         return instance;

     }

调用方法：Singleton instance = Singleton.getInstance();

优点：饿汉式写法能保证线程安全，而且实现简单

缺点：在类加载的时候就完成了实例化，会造成内存浪费（可以忽略不计）

　　2.懒汉式（线程不安全，不可用）

    public class Singleton {  

        private static Singleton instance=null;  

        private Singleton() {};  

        public static Singleton getInstance(){  

            if(instance==null){

                instance=new Singleton();

            }

            return instance;

        }

    }

因为只有在调用getInstance()这个方法的时候，才会去初始化这个单例，所以称为懒汉式

懒汉式存在线程安全问题，当2个或多个线程同时调用getInstance()方法时，有可能发生如下情况：当第一个线程在执行 if(instance==null)判断的时候，因为此时instance为空，他将会执行instance=new Singleton()来实例化对象，而第二个进程也同时进入了 if(instance==null)的判断，他可能会在第一个线程没有实例化之前进行判断，此时instance依旧为空，于是就实例化了2个Singleton对象，违背了单例模式。

于是，就有了懒汉式的双重校验锁

即加锁并且2次判断instance是否为空

public class Singleton2 {//懒汉式双重校检

    private static Singleton2 instance = null;

    private Singleton2(){};

    public static Singleton2 getInstance() {

        if(instance ==null) {

            synchronized (Singleton2.class) {

                if(instance == null){

                    instance = new Singleton2();

                }

            }

        }

2次if(instance == null)校验，确保了线程安全，延迟加载，效率较高

懒汉式双重校验完整例子：

public class Singleton_test {

    private int a =1;

    private static Singleton_test singleton_test =null;

    private Singleton_test(){};

    public static Singleton_test getInstance(){//懒汉式双重校验锁

        if(singleton_test ==null){

            synchronized (Singleton2.class) {

                if(singleton_test ==null){

                    singleton_test =new Singleton_test();

                }

            }

        }

        return singleton_test;

    }

    public int getA() {

        return a;

    }

    public void setA(int a) {

        this.a = a;

    }

    public void printInfo() {

        System.out.println("number" + a);

    } 

}

Singleton_test

public class Main_test {

    public static void main(String[] args){

    Singleton_test singleton_test = Singleton_test.getInstance();

    singleton_test.setA(2);

    Singleton_test singleton_test2 = Singleton_test.getInstance();

    singleton_test2.setA(3);

    singleton_test.printInfo();

    singleton_test2.printInfo();

    if(singleton_test == singleton_test2){

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

    }else{

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

    }  

    }

}

Main_test

内部类

    public class Singleton{  

        private Singleton() {};  

        private static class SingletonHolder{

            private static Singleton instance=new Singleton();

        }   

        public static Singleton getInstance(){

            return SingletonHolder.instance;

        }

    }

和饿汉式类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同

的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时

并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是

无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

参考博客：

http://blog.csdn.net/dmk877/article/details/50311791

巴特西

java设计模式学习-单例模式

最新文章

热门文章