java中单例模式的实现

谁践踏了优雅 2024-03-25 22:52 89阅读 0赞

#### 文章目录 ####

*  单例模式
 *   *  前言
     *  1.饿汉模式
     *   *  1.1 特点
         *  1.2 代码实现
     *  2. 懒汉模式
     *   *  2.1 特点
         *  2.2 代码实现

## 单例模式 ##

### 前言 ###

什么是单例模式？  
单例模式是java设计模式的一种，这个模式的目的就是保证某一个类只有一个实例存在。比如我们java中的DataSource数据源就是需要只有一个实例，是单例模式的一种实现。单例模式由于在内存中只有一个实例，减少了内存的开销，当我们频繁的创建和销毁实例时，并且该模式还能避免对资源的多重占用。  
**单例模式中我们主要分为饿汉模式和懒汉模式，以下介绍这两种模式以及实现方式。**

### 1.饿汉模式 ###

#### 1.1 特点 ####

1.  饿汉模式，顾名思义，该模式会很急促的创建一个实例，它在类初始化时就实例化了一个对象。
2.  饿汉模式它是线程安全的，因为该实例在类加载时就被创建了。
3.  由于饿汉模式在类加载时就被创建，此时我们并不知道这个实例是否需要，所以就会造成资源浪费。对于这种情况我们懒汉模式就是只有我们需要时才会创建，具体将在后面介绍。

#### 1.2 代码实现 ####

package 设计模式;
    
    /**
     * @author zq
     *
     * 单例模式-饿汉模式
     */
    //把这类设定成单例模式
    class Singleton{
        
        //唯一实例的本体，在内部创建好实例
        private static Singleton instance = new Singleton();
        //获取实例的方法
        public static Singleton getInstance(){
        
            return instance;
        }
        //禁止外部new实例
        private Singleton(){
        
            
        }
    }
    public class ThreadDemo11 {
        
        public static void main(String[] args) {
        
            //此时s1和s2是同一个对象
            Singleton s1 = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();
            //但是但凡我们再new时，就会有新的对象。
            //措施，将该类的构造方法设为private
        }
    }

**注意：** 饿汉模式实现时有一下注意点，需要我们掌握。

1.  怎么保证不重复创建多个对象，我们通过对该类中的构造方法进行私有化。
2.  通过在类部就创建好实例，并且定义一个静态方法getInstance（）获取创建好的实例。

### 2. 懒汉模式 ###

#### 2.1 特点 ####

1.  懒汉模式只有在需要实例时才会创建一个实例，不会在类加载时就创建。
2.  在以下代码中我们可以发现我们会涉及到修改，我们判断该对象是否为空时，为空再进行创建对象。此时不仅保证不了if语句和new对象语句的原子性，并且我们new对象时涉及三个CPU指令此时还会由于编译器优化导致指令重排序。 **此处关于线程安全不理解的可以看我写过的一篇博客**[线程不安全的几种情况与解决办法][Link 1]

#### 2.2 代码实现 ####

package 设计模式;
    
    /**
     * @author zq
     * 饿汉模式
     */
    class SingletonLazy{
        
        //volatile修饰该变量，解决指令重排序问题
        volatile private static SingletonLazy instance = null;
    
        public static SingletonLazy getInstance(){
        
            if (instance==null){
        //第一次创建时才加锁。
                synchronized (SingletonLazy.class){
        
                    if (instance==null){
        //饿汉模式，只有需要时才去new一个对象
                        instance = new SingletonLazy();
                    }
                }
    
            }
    
            return instance;
        }
    }
    public class ThreadDemo12 {
        
        public static void main(String[] args) {
        
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
    
            System.out.println(s1==s2);
        }
    }

**注意：** 该代码在线程安全解决方式中有一些注意点

1.  对于上述关于懒汉模式的特点中我们可以知道，一些存在的线程不安全问题。
2.  对于无法保证原子性时，我们通过加上一个if语句判断是否为空，为空时加锁，因为如果我们在  
    原有的if语句前加锁时，我们只要调用getInstance（）就会加锁，此时就涉及阻塞等待。所以我 们通过判断是否为空，为空时加锁，意思是我们需要创建对象了，对后面创建对象的过程加锁。
3.  对于以上无法保证指令重排序问题，我们可以直接在instance前用volatile修饰。

[Link 1]: http://t.csdn.cn/pIj8x