1. 在getInstance方法上加同步。  1. 于getInstance方法上加同步。

View Code

  也是线程安全的,同时避免了历次都同的性损耗

 

 

图片 1图片 2

View Code

    以上懒汉式单例是线程不安全的,并作环境下十分可能出现多个Singleton实例,要促成线程安全,有以下三栽办法,

 

  1. 于getInstance方法上加同步

    以上懒汉式单例是线程不安全的,并作环境下大可能出现多独Singleton实例,要实现线程安全,有以下三栽方式,

View Code

图片 3图片 4

public static synchronized Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
}

  1. 当getInstance方法上加同步

图片 5图片 6

public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
}

图片 7图片 8

  2. 复检查锁定

一. 懒汉式单例

View Code

  虽然线程安全了,但是每次都如同步,会潜移默化性

public static synchronized Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
}
public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
}

  都是针对getInstance这个方法改造,保证了懒汉式单例的线程安全。

View Code

  饿汉式在相近创建的又就是已创办好一个静态的靶子供系统以,以后不再改变,所以自然是线程安全之。

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

图片 9图片 10

 

//饿汉式单例类.在类初始化时,已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

  3. 静态内部类

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  
public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  
//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

图片 11图片 12

图片 13图片 14

View Code

View Code

   线程安全的,同时没有性能损耗,所以一般我同情于采用即时同种植

   线程安全之,同时没有性能损耗,所以一般我同情于下即时等同种

 

View Code

  都是指向getInstance这个方式改造,保证了懒汉式单例的线程安全。

一. 懒汉式单例

  也是线程安全的,同时避免了历次都同的性能损耗

图片 15图片 16

图片 17图片 18

  3. 静态内部类

  饿汉式在类似创建的以就是曾创办好一个静态的目标供系统采取,以后不再改变,所以自然是线程安全之。

  虽然线程安全了,但是每次都使同,会潜移默化性

 

View Code

二. 饿汉式单例

二. 饿汉式单例

//饿汉式单例类.在类初始化时,已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

 

View Code

图片 19图片 20

  2. 又检查锁定

 

相关文章