java设计模式之单例模式

单例模式(Singleton Pattern)

单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

介绍

意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

主要解决:一个全局使用的类频繁地创建与销毁。

何时使用:当您想控制实例数目,节省系统资源的时候。

如何解决:判断系统是否已经有这个单例,如果有则返回,如果没有则创建。

关键代码:构造函数是私有的。

创建方式

  1. 饿汉式(静态常量)
  2. 饿汉式 (静态代码块)
  3. 懒汉式 (线程不安全)
  4. 懒汉式 (线程安全,同步方法)
  5. 懒汉式 (线程安全,同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

代码示例

1.饿汉式(静态常量)

步骤如下:

  1. 构造器私有化(防止 new)
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法。getInstance

代码如下:

public class Singlet {

    //创建对象实例
    private final static Singlet instance = new Singlet();

    //私有构造函数
    private Singlet(){
    }
    //提供一个共有的静态方法,返回实例对象
    public static Singlet getInstance(){
        return instance;
    }
}

优点这种写法比较简单,就是再类装载的时候就完成了实例化,避免了线程同步问题。
缺点在类装载的时候就完成了实例化,没有达到懒加载的效果。如果从始至终没有用到这个类实例,则会造成内存的浪费。
结论这种单例模式可用,可能会造成内存浪费。

2.饿汉式 (静态代码块)

代码实例如下

public class Singlet1 {

    private static Singlet1 instance;
    private Singlet2(){}
    static{
        instance = new Singlet1();
    }
    //提供一个共有的静态方法,返回实例对象
    public static Singlet1 getInstance(){
        return instance;
    }
}

这种方式和上面的方式其实类似,只不过讲类实例化过程放在了静态代码块中,也是在类装载的时候,执行静态代码块中的代码,初始化类的实例。优缺点和上面的一样。

3.懒汉式 (线程不安全)

代码示例:

public class Singlet2 {

    private static Singlet2 instance;
    
    private Singlet2(){}
	//提供一个共有的静态方法,在调用该方法时才创建instance
     public static Singlet2 getInstance(){
         if (instance ==null){
             instance = new Singlet2();
         }
         return instance;
     }
}

优缺点说明
1. 起到了懒加载的作用,但是只能在单线程下使用。
2. 如果在多线程下,一个线程进入了 if(instance ==null)判断语句,还未来的及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

结论:在实际开发种,不要用这种方式

4. 懒汉式 (线程安全,同步方法)

代码实例:

public class Singlet3 {

    private Singlet3(){}

    private static Singlet3 instance;
    //加入同步处理代码,解决线程安全问题
    public static synchronized Singlet3 getInstance(){
        if (instance ==null){
            instance = new Singlet3();
        }
        return instance;
    }
}

优缺点说明:
1. 解决了线程安全问题。
2. 执行效率略低,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步,而其实这个方法只需要执行一次实例化代码就够了,其他线程想获得该类的实例,直接return就行了,方法进行同步影响效率。
结论:在实际开发中,不推荐使用这种方式

5.懒汉式 (线程安全,同步代码块)

代码实例:

public class Singlet4 {
    private Singlet4(){}

    private static Singlet4 instance;
    //加入同步处理代码,解决线程安全问题
    public static Singlet4 getInstance(){
        if (instance ==null){
            synchronized (Singlet4.class){
                instance = new Singlet4();
            }
        }
        return instance;
    }
}

优缺点说明:
1. 这种写法,本意是相对第4种方法的改进,因为前面同步效率太低,改为同步代码块实现。
2. 但是这种同步并不能起到线程同步的作用,它跟第三种实现方式遇到的情况一样,加入一个线程进入了 if(instance ==null)判断语句块,还未来的及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。
结论: 在实际开发中,不能使用这种方式。

6.双重检查(Double-Check)

示例代码:

public class Singlet5 {

    private Singlet5(){}

    private static volatile Singlet5 instance;

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

优缺点说明:
1. Double-Check概念是多线程开发中常使用到的,进行了两次if(instance == null)检查,这样就可以保证线程安全了。
2. 这样实例代码只执行一次。后面再次访问时,判断if(instance == null),直接返回实例化对象,也避免了反复进行方法同步。

线程安全,延迟加载,效率过高。
结论:在实际开发中,推荐使用这种写法。

7.静态内部类

代码示例:

public class Singlet6 {

    private Singlet6(){}

    private static volatile Singlet6 instance;
    //写一个静态内部类,提供一个静态属性
    private static class SingletonInstacne{
        private static final Singlet6 INSTANCE = new Singlet6();
    }

    //静态公用方法,可在直接返回
    public static synchronized Singlet6 getInstance(){
        return SingletonInstacne.INSTANCE;
    }
}

优缺点说明:
1. 这种方式采用了类加载机制来保证实例化时只有一个线程。
2. 静态内部类方式在Singlet6类被加载时并不会立即实例化,而是在需要实例化的时候,调用getInstacne方法,才会完成实例化。
3. 类的静态属性只会在第一次加载类的时候实例化,所以在这里,jvm帮助我们保证了线程的安全。在类进行初始化的时候,别的线程时无法进入的。
优点:避免了线程不安全,利用静态内部类的特点实现延迟加载,效率高。
结论: 推荐使用。

8.枚举

示例代码:

public enum Singlet7 {
    INSTANCE;
    public void Method1(){
        System.out.println("方法1");
    }

    public void Method2(){
        System.out.println("方法2");
    }
}
//调用
    public static void main(String[] args) {
        Singlet7.INSTANCE.Method1();
        Singlet7.INSTANCE.Method2();
    }

优缺点说明:
1. 这中方式是借助JDK1.5中添加枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,绝对防止多次实例化。
2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。不过,由于 JDK1.5 之后才加入 enum 特性,用这种方式写不免让人感觉生疏,在实际工作中,也很少用。
结论:推荐使用。

注意事项和细节说明

  1. 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。
  2. 当想实例化一个单例类的时候,必须要记住使用相应的获取对象方法,而不是new。
  3. 使用场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或者耗费资源过多(重量级对象),但又不经常使用到的对象、工具类对象,频繁访问数据库文件的对象(比如数据源、session工厂)。

你可能感兴趣的:(JAVA,设计模式,java,设计模式,单例模式)