平武建站

怎么实现Java单例模式

本篇内容主要讲解“怎么实现Java单例模式”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“怎么实现Java单例模式”吧!

创新互联服务项目包括常州网站建设、常州网站制作、常州网页制作以及常州网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，常州网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到常州省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

介绍

单例模式（Singleton Pattern）是一个比较简单的设计模式，属于创建型模式。其定义为

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

在系统中，单例模式要求一个单例对象只能有一个实例，这类对象如果有多个实例就可能会产生一些问题，如：资源消耗过多，处理结果不一致等，一般单例会有以下使用场景

  • 生成唯一 序列号

  • 整个项目的共享访问点或共享数据，如Web页面计数器

  • 创建一个对象实例需要消耗过多资源，如I/O和数据库连接等

在Java中，一个单例对象在一个JVM中，只会有一个实例存在。以下是单例模式结构图

怎么实现Java单例模式

  • 有一个该单例对象的静态成员变量

  • 私有的构造函数，只能被自身实例化

  • 提供一个静态公共方法实例化对象，并访问该对象实例

单例模式实现

单例模式有两种实现方式：

  • 饿汉式

  • 懒汉式(延迟加载)

饿汉式

/**
 * 饿汉式单例
 */
public class Singleton1 {
    // 静态成员变量，在静态初始化时便实例化对象
    private static final Singleton1 singleton = new Singleton1();
    // 构造私有
    private Singleton1(){
    }
    public static Singleton1 getSingletonInstance(){
        return singleton;
    }
}

饿汉式指的是，在类加载的时候便实例化了该单例对象，不管有没有使用，先创建了再说。这种方式是可以保证线程安全的，但是如果该对象一直没有被使用，就浪费了空间资源。

但是对于一些空间占用较大、或是只在某些特定场景才使用的单例，我们会想要在第一次使用的时候才去实例化，这时，就需要懒汉式的延迟加载

懒汉式

/**
 * 懒汉式单例（非线程安全）
 */
public class Singleton2 {
    private static Singleton2 singleton;
    private Singleton2(){}
    // 获取实例
    public static Singleton2 getSingletonInstance(){
        if(singleton == null){
            singleton =  new Singleton2();
        }
        return singleton;
    }
}

从上面代码可以看出，懒汉式与饿汉式在于单例对象的创建时机。饿汉式是在类加载时便实例化对象，调用时无须判断直接返回即可；而懒汉式是在第一次调用时实例化，并且每次调用都需要判断是否已经实例化

但是上面的这种方式在多线程下是不安全的，多个线程同时访问getSingletonInstance()时，可能会创建多个实例，便不再是单例了。那怎么解决线程安全的问题呢？首先我们可能会想到对getSingletonInstance()方法加上synchronized关键字

/**
 * 懒汉式单例（synchronized关键字线程安全）
 */
public class Singleton3 {
    private static Singleton3 singleton;
    private Singleton3(){}
    // 获取实例
    public static synchronized Singleton3 getSingletonInstance(){
        if(singleton == null){
            singleton =  new Singleton3();
        }
        return singleton;
    }
}

getSingletonInstance()方法加上了同步锁，增加了获取实例的时间消耗，且在多线程下可能会发生阻塞。但其实我们并不想每次获取实例的时候都去加上锁，只是想在第一次调用创建对象时保证线程安全即可

双重校验锁（DCL）

对getSingletonInstance()方法加上锁，确实能保证线程安全，却存在性能的问题。是不是要必要对整个方法加锁？还是当我检查到实例还没有创建，才去同步

**双重校验锁（double-checked locking，DCL）**是能解决这个问题的

/**
 * 双重校验锁（double-checked locking，DCL）
 */
public class Singleton4 {
     /**
     * 成员变量这里会加上关键字 volatile，目的是为了防止指令重排序
     */
    private static volatile Singleton4 singleton;
    private Singleton4(){}
    // 获取实例
    public static Singleton4 getSingletonInstance(){
        // 第一次校验，没有实例化才进入同步代码块
        if(singleton == null){
            synchronized (Singleton4.class){
                // 进入同步代码块后，再判断，如果为空才创建实例
                if(singleton == null){
                    singleton =  new Singleton4();
                }
            }
        }
        return singleton;
    }
}

不对方法加上锁，只对创建实例的代码加锁即可。方法中会有两次判空的操作，第一次是为了不必要的同步，为null才进入同步代码块，第二次是进入同步代码块后判断为null才创建实例

注意：这里的成员变量加上了volatile关键字

使用volatile可以保证数据的可见性，不过synchronized也是能保证同步数据的可见性的，这里使用volatile更多的目的是为了禁止Java指令重排序

静态内部类

/**
 * 静态内部类
 */
public class Singleton5 {
    private Singleton5(){}

    // 获取实例
    public static Singleton5 getSingletonInstance(){
        return SingletonHolder.SINGLETON;
    }

    /**
     * 内部类，JVM在类加载的时候，是互斥的，可以保证线程安全
     */
    private static class SingletonHolder{
        private static final Singleton5 SINGLETON = new Singleton5();
    }
}

JVM在类加载的时候是会保证数据同步的，我们可以通过内部类来创建单例对象。第一次加载Singleton5时并不会加载内部类，不去使用内部类的时候，该内部类就不会加载。只有第一次调用getSingletonInstance()方法，会去加载内部类并实例化单例对象，这样就可以做到延迟加载和线程安全了

枚举方式

使用枚举方式来实现单例是非常简洁的，支持序列化机制，绝对防止多次实例化

/**
 * 枚举方式
 */
public enum Singleton6 {

    /**
     * 枚举方式实现单例
     */
    SINGLETON;

    public void handle() {
        // to do something
    }
}

该单例的使用方法

public class SingletonDemo {

    @Test
    public void test(){
        // 枚举方式
        Singleton6 singleton = Singleton6.SINGLETON;
        singleton.handle();
    }
}

到此，相信大家对“怎么实现Java单例模式”有了更深的了解，不妨来实际操作一番吧！这里是创新互联网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！


文章题目：怎么实现Java单例模式
转载来于：http://pwwzsj.com/article/ijcdpj.html

其他资讯