设计模式随笔

设计模式

设计模式是为了让程序，具有更好的

代码重用性
可读性
可扩展性
可靠性
使程序呈现高内聚低耦合

一、设计模式七大原则

单一职责原则
接口隔离原则
依赖倒转原则
里氏替换原则
开闭原则
迪米特法则
合成复用原则

二、单例模式

1.饿汉式(静态常量)

步骤：

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

代码实现

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
    }
}

class Singleton {
    // 1.构造器私有化
    private Singleton(){
        
    }
    // 2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    // 3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点

优点
- 写法简单，在类装载的时候就完成了实例化，避免了线程同步的问题
缺点
- 在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终都未使用过这个实例，则会造成内存的浪费
总结
- 这种方式基于classloader机制避免了多线程同步的问题，不过，instance在类装载时就实例化，在单例模式中大都是调用getInstance放法，但导致类装载的原因有很多种，因此不能确定有其他方式(或者其他静态放法)导致类装载。这时候初始化就没有达到lazy loading的效果
- 这种单例模式可用，可能造成内存浪费

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

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
    }
}

class Singleton {
    // 1.构造器私有化
    private Singleton(){
        
    }
    // 2.本类内部创建对象实例
    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }
    // 3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点同上

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

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
    }
}

class Singleton {
    private static Singleton instance;
    // 1.构造器私有化
    private Singleton(){
        
    }
    // 2.提供一个静态的公有方法，当时用到该方法时，才去创建instance
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}

优缺点

优点
- 起到了lazylaoding的效果，但只能单线程下使用
缺点
- 如果在多线程下，一个线程进入了if(singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这是便会产生多个实例，所以多线程模式下不可以使用这种方式
结论
- 在实际开发环境，不要使用这种方式

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

class Singleton{
    private Singleton instance;
    private Singleton(){
        
    }
    public static synchroized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点

解决了线程同步的问题
效率不高

5.懒汉式(双重检查)

class Singleton{
    // volatile关键字防止了指令重排
    private static volatile Singleton instance;
    private Singleton(){
        
    }
    public static Singleton getInstance() {
        if(instance == null) {
            synchronized(Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
                return instance;
            }
        }
        return instance;
    }
}

优缺点

优点
- Double-Check概念是多线程开发中经常使用到的，如代码所示，我们进行了两次if(singleton==null)检查，这样就可以保证线程安全了
- 这样只用执行一次，后面再次访问时，判断if(singleton==null)直接return实例化对象，也避免反复进行放法同步
- 线程安全，延迟加载，效率较高
结论
- 在实际开发中，推荐使用这种单例设计模式

*关于volatile关键字

volatile关键字保证了内存可见性的同时，保证了cpu执行时不会进行指令重排，当创建对象时要进行很多步的操作，在执行指令时，程序会优先执行new关键字，为对象分配内存，然后再进行类的初始化。这样的话如果有一个线程刚进行完内存的分配但未完全对该对象进行初始化，这时另外一个线程访问第一道if检查时会返回未初始化完成的对象，从而导致程序的错误

6.静态内部类

class Singleton {
    private Singleton(){}
    
    // 写一个静态内部类该类种有一个静态的属性
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    //提供一个静态的公有方法，直接返回Singleton.INSTANCE
    public static synchroized Singleton getInstance() {
        return SingletionInstance.INSTANCE;
    }
}

解释

Singleton进行类装载的时候，静态内部类SingletonInstance并不会被装载
当调用Singleton.getInstance()时对象被创建

优缺点

这种方式采用了类装载的机制来保证初始化实例时只有一个线程
静态内部类方式在Singleton类被装载时并不会立刻实例化，而是在需要实例化时调用getInstance()放法时才会装载SingletonInstance类，从而完成Singleton的实例化
类的静态属性只会在第一次加载类的时候初始化，所以这里JVM帮助我们保证了线程的安全，在类进行初始化时，别的线程时无法进入的
避免了线程的不安全性，利用静态内部类的特点实现延迟加载，效率高
推荐使用

7.枚举

enum Singleton {
    INSTANCE;
    public void sayOK() {
        
    }
}

优缺点

借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，还能防止反序列化重新创建对象
推荐使用

posted @ 2021-03-03 20:30 Zmyy 阅读(40) 评论(0) 收藏举报

刷新页面返回顶部

芝麻盐