您的位置:

java线程安全的单例模式代码(单例实现线程安全)

本文目录一览:

如何高效的创建一个线程安全的单例

单例模式的概念

单例模式就是确保只有一个实例,而且自行实例化并向整个系统传递这个实例,这个类就称作为单例类

单例模式最重要的一个特点就是构造方法私有化。创建单例模式分为懒汉式和饿汉式。

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

传统的懒汉式创建单例模式,是线程不安全的

[java] view plain copy print?

public class Singleton {

private static Singleton instance;

private Singleton (){}

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

所谓懒汉式单例模式就是在调用的时候才去创建这个实例。这种写法的懒加载很明显,但是缺点就是不能再多线程访问下正常工作。

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

[java] view plain copy print?

public class Singleton {

private static Singleton instance;

private Singleton (){}

public static synchronized Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

线程安全的方式创建单例就是在对外的创建实例方法上加上synchronized。 这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy

loading,但是,遗憾的是,效率很低,99%情况下不需要同步。

第三种:饿汉式(是线程安全的)

[java] view plain copy print?

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton (){}

public static Singleton getInstance() {

return instance;

}

}

这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy

loading的效果。

第四种:静态内部类的方式创建单例模式(static inner class)

[java] view plain copy print?

public class Singleton {

private Singleton() {

}

private static class SingletonHolder {// 静态内部类

private static Singleton singleton = new Singleton();

}

public static Singleton getInstance() {

return SingletonHolder.singleton;

}

}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,它跟第三种方式不同的是(很细微的差别):第三种方式是只要Singleton类被装载了,那么instance就会被实例化(没有达到lazy

loading效果),而这种方式是Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化singleton。想象一下,如果实例化singleton很消耗资源,我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三种方式就显得很合理。

第五种:双重校验锁(dubble check instance)

[java] view plain copy print?

public class Singleton {

private static Singleton singleton;

private Singleton() {

}

public static Singleton getInstance(){

if (singleton == null) {

synchronized (Singleton.class) {

if (singleton == null) {

/**

* 为什么这里会使用双重判定呢?

*/

singleton = new Singleton();

}

}

}

return singleton;

}

}

这种事用双重判断来创建一个单例的方法,那么我们为什么要使用两个if判断这个对象当前是不是空的呢

?因为当有多个线程同时要创建对象的时候,多个线程有可能都停止在第一个if判断的地方,等待锁的释放,然后多个线程就都创建了对象,这样就不是单例模式了,所以我们要用两个if来进行这个对象是否存在的判断。

Java的单例模式是不是线程安全的

单例也不能保证100%线程安全的。解决方法就是创建实例方法中加入java关键字synchronized。

java语言的关键字synchronized,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而,当一个线程访问object的一个加锁代码块时,另一个线程仍然可以访问该object中的非加锁代码块。

java单例模式出现空指针问题。

1.首先单例模式,构造方法要私有化,private   Cart (){}  ;

2.private MapGoodsBean,Integer  cartMap;你不分配空间给map,就会报空指针异常,要

3.实现线程安全的单例模式,不难

//双重检查实现单例

public class Singleton {    

    private static volatile Singleton singleton;    

    private Singleton() {}    

    public static Singleton getInstance() {       

        if (singleton == null) {            

            synchronized (Singleton.class) {                

                if (singleton == null) {                    

                    singleton = new Singleton();                

                }            

            }        

        }        

        return singleton;    

   }

}

4.Double-Check概念对于多线程开发者来说不会陌生,如代码中所示,我们进行了两次if (singleton == null)检查,这样就可以保证线程安全了。这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == null),直接return实例化对象。

优点:线程安全;延迟加载;效率较高。

java几种单例模式写法

懒汉模式

public class SingletonDemo {

private static SingletonDemo instance;

private SingletonDemo(){}public static SingletonDemo getInstance(){

if(instance==null){

instance=new SingletonDemo();

}

return instance;

}}

2. 线程安全的懒汉模式

public class SingletonDemo {

private static SingletonDemo instance;

private SingletonDemo(){}

public static synchronized SingletonDemo getInstance(){

if(instance==null){

instance=new SingletonDemo();

}

return instance;

}}

3. 饿汉模式

public class SingletonDemo {

private static SingletonDemo instance=new SingletonDemo();

private SingletonDemo(){}

public static SingletonDemo getInstance(){

return instance;

}}

4. 静态类内部加载

public class SingletonDemo {

private static class SingletonHolder{

private static SingletonDemo instance=new SingletonDemo();

}

private SingletonDemo(){

System.out.println("Singleton has loaded");

}

public static SingletonDemo getInstance(){

return SingletonHolder.instance;

}}

5.双重校验锁法

public class SingletonDemo {

private volatile static SingletonDemo instance;

private SingletonDemo(){

System.out.println("Singleton has loaded");

}

public static SingletonDemo getInstance(){

if(instance==null){

synchronized (SingletonDemo.class){

if(instance==null){

instance=new SingletonDemo();

}}}

return instance;

}}

如何正确地写出单例模式

当被问到要实现一个单例模式时,很多人的第一反应是写出如下的代码,包括教科书上也是这样教我们的。

1

2

3

4

5

6

7

8

9

10

11

public class Singleton {

private static Singleton instance;

private Singleton (){}

public static Singleton getInstance () {

if (instance == null ) {

instance = new Singleton();

}

return instance;

}

}

这段代码简单明了,而且使用了懒加载模式,但是却存在致命的问题。当有多个线程并行调用 getInstance() 的时候,就会创建多个实例。也就是说在多线程下不能正常工作。

懒汉式,线程安全

为了解决上面的问题,最简单的方法是将整个 getInstance() 方法设为同步(synchronized)。

1

2

3

4

5

6

public static synchronized Singleton getInstance () {

if (instance == null ) {

instance = new Singleton();

}

return instance;

}

虽然做到了线程安全,并且解决了多实例的问题,但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要,即第一次创建单例实例对象时。这就引出了双重检验锁。

双重检验锁

双重检验锁模式(double checked locking pattern),是一种使用同步块加锁的方法。程序员称其为双重检查锁,因为会有两次检查 instance == null ,一次是在同步块外,一次是在同步块内。为什么在同步块内还要再检验一次?因为可能会有多个线程一起进入同步块外的 if,如果在同步块内不进行二次检验的话就会生成多个实例了。

1

2

3

4

5

6

7

8

9

10

public static Singleton getSingleton () {

if (instance == null ) { //Single Checked

synchronized (Singleton.class) {

if (instance == null ) { //Double Checked

instance = new Singleton();

}

}

}

return instance ;

}

这段代码看起来很完美,很可惜,它是有问题。主要在于 instance = new Singleton() 这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情。

给 instance 分配内存

调用 Singleton 的构造函数来初始化成员变量

将instance对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错。

我们只需要将 instance 变量声明成 volatile 就可以了。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

public class Singleton {

private volatile static Singleton instance; //声明成 volatile

private Singleton (){}

public static Singleton getSingleton () {

if (instance == null ) {

synchronized (Singleton.class) {

if (instance == null ) {

instance = new Singleton();

}

}

}

return instance;

}

}

有些人认为使用 volatile 的原因是可见性,也就是可以保证线程在本地不会存有 instance 的副本,每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性:禁止指令重排序优化。也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。比如上面的例子,取操作必须在执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话,就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即时将变量声明成 volatile 也不能完全避免重排序,主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile。

相信你不会喜欢这种复杂又隐含问题的方式,当然我们有更好的实现线程安全的单例模式的办法。

饿汉式 static final field

这种方法非常简单,因为单例的实例被声明成 static 和 final 变量了,在第一次加载类到内存中时就会初始化,所以创建实例本身是线程安全的。

1

2

3

4

5

6

7

8

9

10

public class Singleton {

//类加载时就初始化

private static final Singleton instance = new Singleton();

private Singleton (){}

public static Singleton getInstance (){

return instance;

}

}

这种写法如果完美的话,就没必要在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式(lazy initialization),单例会在加载类后一开始就被初始化,即使客户端没有调用 getInstance()方法。饿汉式的创建方式在一些场景中将无法使用:譬如 Singleton 实例的创建是依赖参数或者配置文件的,在 getInstance() 之前必须调用某个方法设置参数给它,那样这种单例写法就无法使用了。

静态内部类 static nested class

我比较倾向于使用静态内部类的方法,这种方法也是《Effective Java》上所推荐的。

1

2

3

4

5

6

7

8

9

public class Singleton {

private static class SingletonHolder {

private static final Singleton INSTANCE = new Singleton();

}

private Singleton (){}

public static final Singleton getInstance () {

return SingletonHolder.INSTANCE;

}

}

这种写法仍然使用JVM本身机制保证了线程安全问题;由于 SingletonHolder 是私有的,除了 getInstance() 之外没有办法访问它,因此它是懒汉式的;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖 JDK 版本。

枚举 Enum

用枚举写单例实在太简单了!这也是它最大的优点。下面这段代码就是声明枚举实例的通常做法。

1

2

3

public enum EasySingleton{

INSTANCE;

}

我们可以通过EasySingleton.INSTANCE来访问实例,这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的,所以不需要担心double checked locking,而且还能防止反序列化导致重新创建新的对象。但是还是很少看到有人这样写,可能是因为不太熟悉吧。

总结

一般来说,单例模式有五种写法:懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现,文章开头给出的第一种方法不算正确的写法

Java的单例模式是不是线程安全的?

单例也不能保证100%线程安全的。解决方法就是创建实例方法中加入Java关键字synchronized。

Java语言的关键字synchronized,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而,当一个线程访问object的一个加锁代码块时,另一个线程仍然可以访问该object中的非加锁代码块。