0
点赞
收藏
分享

微信扫一扫

Zabbix企业级分布式监控环境部署

西特张 2024-11-06 阅读 26

1.单例模式概念:

2.饿汉式

饿汉就是一个迫切的意思,类加载就会导致该单实例被创建

饿汉式第一种方式:

class Singleton{

//在本类中创建本类对象
    private static Singleton instance=new Singleton();

//提供一个公共的访问方式,让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }

//私有构造方法
    private Singleton() {
    }
}

我们来对上面这个饿汉式解析一下:

饿汉式第二种方式:

class Singleton2{

private static Singleton2 instance ;

static {
    instance=new Singleton2();
}

//对外提供方法获取该对象
public static Singleton2 getInstance(){
    return instance;
}

    //私有化的构造方法
    private Singleton2() {
    }
}

饿汉式第三种方式(枚举方式):

public enum Singleton3{
    instance;
}

饿汉式总结说明:

这种方式在成员位置声明Singlleton类型的静态变量,并创建Singleton类的对象instance。instance对象会随着类的加载而创建。如果对象足够大1的话,而一直没有使用就会造成内存的浪费

2.懒汉式

类加载不会导致该单实例对象被创建,而是首次使用才会被创建

懒汉式第一种方式(线程不安全的):

class Singleton3{
//声明成员变量,不进行初始化
    private static Singleton3 instance;

//提供获取对象的方法
    public static Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }

//私有化的构造方法
    private Singleton3() {
    }
}

懒汉式第二种方式(线程安全的):

class Singleton3{
    private static Singleton3 instance;

    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }
    private Singleton3() {
    }
}

懒汉式第三种方式(双重检查锁):

class Singleton3{
    private static Singleton3 instance;

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

对双重检查锁的优化:

class Singleton3{
    private static volatile Singleton3 instance;

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

添加volatile关键字之后,能够保证多线情况下的线程安全也不会有性能问题

懒汉式第四种方式(静态内部类):

class Singleton4{
private static class SingletonHolder{
private final static Singleton4 INSTANCE=new Singleton4();    
}

public static Singleton4 getInstance(){
    return SingletonHolder.INSTANCE;
}
    private Singleton4() {
    }
}

静态内部类的方式在没有加锁的情况下,保证了线程安全,有没有影响性能和空间的浪费

举报

相关推荐

0 条评论