单例模式——Java实现

饿汉法

顾名思义,饿汉法就是在第一次引用该类的时候就创建对象实例,而不管实际是否需要创建。代码如下:

1

2

3

4

5

6

7

public class Singleton {  

    private static Singleton = new Singleton();

    private Singleton() {}

    public static getSignleton(){

        return singleton;

    }

}

这样做的好处是编写简单,但是无法做到延迟创建对象。但是我们很多时候都希望对象可以尽可能地延迟加载,从而减小负载,所以就需要下面的懒汉法:

懒汉法:单线程写法

1

2

3

4

5

6

7

8

public class Singleton {

    private static Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton() {

        if(singleton == null) singleton = new Singleton();

        return singleton;

    }

}

懒汉法:考虑线程安全的写法

1

2

3

4

5

6

7

8

9

10

11

12

13

14

public class Singleton {

    private static volatile Singleton singleton = null;

 

    private Singleton(){}

 

    public static Singleton getSingleton(){

        synchronized (Singleton.class){

            if(singleton == null){

                singleton = new Singleton();

            }

        }

        return singleton;

    }   

}

懒汉法:兼顾线程安全和效率的写法

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

public class Singleton {

    private static volatile Singleton singleton = null;

 

    private Singleton(){}

 

    public static Singleton getSingleton(){

        if(singleton == null){

            synchronized (Singleton.class){

                if(singleton == null){

                    singleton = new Singleton();

                }

            }

        }

        return singleton;

    }   

}

这种写法被称为“双重检查锁”,在单例中new的情况非常少,绝大多数都是可以并行的读操作。因此在加锁前多进行一次null检查就可以减少绝大多数的加锁操作,执行效率提高的目的也就达到了。

懒汉法:静态内部类法

那么,有没有一种延时加载,并且能保证线程安全的简单写法呢?我们可以把Singleton实例放到一个静态内部类中,这样就避免了静态实例在Singleton类加载的时候就创建对象,并且由于静态内部类只会被加载一次,所以这种写法也是线程安全的:

1

2

3

4

5

6

7

8

9

10

11

public class Singleton {

    private static class Holder {

        private static Singleton singleton = new Singleton();

    }

 

    private Singleton(){}

 

    public static Singleton getSingleton(){

        return Holder.singleton;

    }

}

但是,上面提到的所有实现方式都有两个共同的缺点:

  • 都需要额外的工作(Serializable、transient、readResolve())来实现序列化,否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
  • 可能会有人使用反射强行调用我们的私有构造器(如果要避免这种情况,可以修改构造器,让它在创建第二个实例的时候抛异常)。

枚举写法

当然,还有一种更加优雅的方法来实现单例模式,那就是枚举写法:

1

2

3

4

5

6

7

8

9

10

public enum Singleton {

    INSTANCE;

    private String name;

    public String getName(){

        return name;

    }

    public void setName(String name){

        this.name = name;

    }

}

使用枚举除了线程安全和防止反射强行调用构造器之外,还提供了自动序列化机制,防止反序列化的时候创建新的对象。

 

 

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值