什么是线程安全的单例？_Java

8条回答

灰机带翅膀

1楼 · 2021-04-30 11:40.采纳回答

单例模式是为确保一个类只有一个实例，并为整个系统提供一个全局访问点的一种模式方法。

从概念中体现出了单例的一些特点：

（1）、在任何情况下，单例类永远只有一个实例存在

（2）、单例需要有能力为整个系统提供这一唯一实例

要保证线程安全，我们就得需要使用同步锁机制

风中浪子

2楼 · 2021-04-30 14:23

第一种：饿汉模式

public class Single2 {    private static Single2 instance = new Single2();    
    private Single2(){
        System.out.println("Single2: " + System.nanoTime());
    }    
    public static Single2 getInstance(){        return instance;
    }
}

第二种：懒汉模式

public class Single3 {    private static Single3 instance = null;    
    private Single3(){
        System.out.println("Single3: " + System.nanoTime());
    }    
    public static synchronized Single3 getInstance(){        if(instance == null){
            instance = new Single3();
        }        return instance;
    }
}

第三种：懒汉模式改良版

public class Single4 {    private volatile static Single4 instance = null;    
    private Single4(){
        System.out.println("Single4: " + System.nanoTime());
    }    
    public static Single4 getInstance(){        if(instance == null){            synchronized (Single4.class) {                if(instance == null){
                    instance = new Single4();
                }
            }
        }        return instance;
    }
}

第四种：利用私有的内部工厂类

public class Singleton {    
    private Singleton(){
        System.out.println("Singleton: " + System.nanoTime());
    }    
    public static Singleton getInstance(){        return SingletonFactory.singletonInstance;
    }    
    private static class SingletonFactory{        private static Singleton singletonInstance = new Singleton();
    }
}

小蹲蹲

3楼 · 2021-04-30 16:33

第一双重检查加锁,防止多线程同时创建；

第二要用voliate防止创建对象的3步指令重排序132顺序下可能拿到没有初始化好的但是有地址的对象;

额外私有构造是不管多不多线程下都要用

杨晓春

4楼 · 2021-04-30 16:46

意图

保证一个类仅有一个实例，并提供一个访问它的全局访问点。节省内存。用途：计数器，全局唯一ID、连接等。

类图

实例

实例中只展示线程安全的实现方式

// 第一种，并且是最好的实现方式，枚举，饿汉式

enum Single1{

SINGLETON;

public void sayHello(){

System.out.println("enum say hello");

}

// 第二种，常规饿汉式

class Single2{

private Single2(){}

private static final Single2 SINGLE = new Single2();

public static Single2 getInstance(){

return SINGLE;

}

public void sayHello(){

System.out.println("饿汉式 say hello");

}

// 第三种，静态内部类，懒汉式，懒汉式首选

class Single3{

private Single3(){}

private static class SingleHolder{

private static final Single3 SNGLE = new Single3();

}

public static Single3 getInstance(){

return SingleHolder.SNGLE;

}

public void sayHello(){

System.out.println("inner static say hello");

}

// 双重校验锁, 懒汉式

class Single4{

private Single4(){}

private static Single4 single4;

public static Single4 getInstance(){

if(null == single4){

synchronized (Single4.class){

if(null == single4){

return new Single4();

}

return single4;

}

public void sayHello(){

System.out.println("double judge say hello");

}

// 直接加锁，懒汉式，效率最低

class Single5{

private Single5(){}

private static Single5 single5;

public static synchronized Single5 getInstance(){

if(null == single5){

return new Single5();

}

return single5;

}

public void sayHello(){

System.out.println("normal sync lazy say hello");

}

测试

class TestSingleton{

public static void main(String[] args) {

Single1.SINGLETON.sayHello();

Single2.getInstance().sayHello();

Single3.getInstance().sayHello();

Single4.getInstance().sayHello();

Single5.getInstance().sayHello();

}

运行结果：

enum say hello

饿汉式 say hello

inner static say hello

double judge say hello

normal sync lazy say hello

aijingda

5楼 · 2021-04-30 17:03

单例，就是无论如何都只生成一个对象，如果这个对象没有成员变量，那么他肯定是线程安全的，如果有成员变量，并且成员变量参与结果的运算，要想保证这个对象在多线程的情况安全，那就需要特殊的手段了，一般情况下，在 JAVA 语言中，我们利用 synchronized，lock 和 cas 乐观锁等来实现数据同步，从而达到这个唯一对象线程安全。

嘿呦嘿呦拔萝卜

6楼 · 2021-04-30 18:20

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

ZGSYT

7楼 · 2021-05-06 10:57

线程安全就是，某一资源是固定的，只有这一个线程可在一个时间对该资源进行操作，其余线程在这时不可占用该资源，需要等待上一线程使用完该资源

123无语呀

8楼 · 2021-11-25 10:28

单例，就是无论如何都只生成一个对象，如果这个对象没有成员变量，那么他肯定是线程安全的，如果有成员变量，并且成员变量参与结果的运算，要想保证这个对象在多线程的情况安全，那就需要特殊的手段了。