java中的单例模式。

概念：只允许创建一个该类的对象

 

第一种：

饿汉式：天生线程安全（无锁）、
类加载时创建（不用的时候，也被迫创建了，占用资源）

 

class Singleton{
private static final Singleton instance = new Singleton();//私有静态常量
private Singleton() {}//私有构造方法
public static Singleton getInstance() {//通过调用静态方法创建对象
           return instance;
     }
}

 

第二种：

懒汉式：使用时创建、天生线程不安全(加同步锁); 效率低

class Singleton{
private static Singleton instance = null;//私有静态最初为null
private Singleton() {}//私有构造方法
public synchronized static Singleton getInstance() {
        if(instance == null) {//第一次创建时
        instance = new Singleton();
}
        return instance;//返回对象
}
}

 

第三种：

懒汉式（加强版）：使用时创建、天生线程安全

class Singleton{
private Singleton() {}
private static class Holder{//私有内部类
static final Singleton instance= new Singleton();
}
public static Singleton getInstance() {
return Holder.instance;//调用私有内部类
}
}

 

这儿还有一个自己原来遇见的一个很有意思的案例：

public class TestSignleton {

    public static void main(String[] args) {
        
        Signleton s = Signleton.getSignleton();
        System.out.println(Signleton.count1);
        System.out.println(Signleton.count2);
        

    }

}

class Signleton {
    private static Signleton signleton = new Signleton();
    public static int count1;
    public static int count2 = 0;

    private Signleton() {
        count1++;
        count2++;
    }

    public static Signleton getSignleton() {
        return signleton;
    }

}

 

运行结果：

1
0