java中的单例设计模式详解

女爷i 2022-06-13 08:00 92阅读 0赞

设计模式：对问题行之有效的解决方式，其实就是一种思想。

## 1.单例设计模式。 ##

解决的问题：就是可以保证一个类在内存中的对象唯一性。  
比如对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

*  如何保证对象唯一性？  
    1.不允许其他程序用new创建该类对象。  
    2.在该类创建一个本类实例  
    3.对外提供一个方法让其他程序可以获取该对象。
 *  步骤：  
    1.私有化该类构造函数  
    2.通过new在本类中创建一个本类对象。  
    3.定义一个公有的方法，将创建的对象返回。

例如：（将下面的程序改为单例设计模式）

public class Dmo10 {
        public static void main(String[] args) {
            Test t1 = new Test();
            Test t2 = new Test();
            t1.setNum(10);
            t2.setNum(20);
            System.out.println(t1.getNum());
            System.out.println(t2.getNum());
        }
    }
    
    class Test {
        private int num;
    
        public void setNum(int num) {
            this.num = num;
        }
    
        public int getNum() {
            return num;
        }
    }
    结果：
    10
    20

改变之后

public class Dmo10 {
        public static void main(String[] args) {
            Test t1 = Test.getInstance();
            Test t2 = Test.getInstance();
            t1.setNum(10);
            t2.setNum(20);
            System.out.println(t1.getNum());
            System.out.println(t2.getNum());
        }
    }
    
    class Test {
        private int num;
    
        private static Test t = new Test();
        private Test() {}
    
        public static Test getInstance() {
            return t;
        }
        public void setNum(int num) {
            this.num = num;
        }
    
        public int getNum() {
            return num;
        }
    }
    结果：
    20
    20

*  单例设计模式有两种方式:饿汉模式和懒汉模式

饿汉模式：类加载的时候对象就已经存在，饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变。

public class Single {
    
        private static Single s=new Single();
        private Single(){
    
        }
        public static Single getInstance(){
            return s;
        }
    }

懒汉模式：类加载的时候对象还不存在，就是所谓的延迟加载方式，需要时再进行创建，懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。

public class Single {
    
        private static Single single = null;
    
        private Single() {
    
        }
    
        public static Single getInstance() {
            if (single == null) {
                single = new Single();
            }
            return single;
        }
    }

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步

public static synchronized Single getInstance() {  
             if (single == null) {    
                 single = new Single();  
             }    
            return single;  
    }

2、双重检查锁定

public static Single getInstance() {  
            if (single == null) {    
                synchronized (Single.class) {    
                   if (singleton == null) {    
                      single = new Single();   
                   }    
                }    
            }    
            return single;   
        }

3、静态内部类

public class Single {    
        private static class LazyHolder {    
           private static final Single INSTANCE = new Single();    
        }    
        private Single (){}    
        public static final Single getInstance() {    
           return LazyHolder.INSTANCE;    
        }    
    }

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。