构造器私有
保证一个类仅有一个实例,并提供一个访问它的全局访问点
通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象.
一个最好的方法就是,让类自身负责保存它的唯一实例.这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的方法
懒汉式单例(在第一次调用的时候实例化自己)
饿汉式单例(在类初始化时,已经自行实例化) 在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的.
枚举实现单例
枚举类反编译后发现enum ClassA 等于public final class T extends Enum
枚举单例(???)
enum SingletonDemo{INSTANCE;public void otherMethods(){System.out.println("Something");}
}
/**
* 懒汉式单例,在第一次调用的时候实例化自己(线程不安全)
* @author guk
*
*/
public class Singleton {
// 构造器私有
private Singleton() {
}
private static Singleton single = null;
//静态工厂方法
public static Singleton getInstance() {
if (single == null) {
single = new Singleton();
}
return single;
}
}
/**
* 对懒汉式进行改造,使其线程安全(第一种方法)
* @author guk
*
*/
public class Singleton2 {
// 构造器私有
private Singleton2() {
}
private static Singleton2 single = null;
//静态工厂方法上加同步
public static synchronized Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
/**
* 对懒汉式进行改造,使其线程安全(第二种方法)
* @author guk
*
*/
public class Singleton3 {
// 构造器私有
private Singleton3() {
}
private static Singleton3 single = null;
//静态工厂方法上双重检查锁定
public static Singleton3 getInstance() {
if (single == null) {
synchronized (Singleton3.class) {
if (single == null) {
single = new Singleton3();
}
}
}
return single;
}
}
/**
* 对懒汉式进行改造,使其线程安全(第三种方法,比一,二都好,既实现了线程安全,又避免了同步带来的性能影响)
* @author guk
*
*/
public class Singleton4 {
private static class LazyHolder{
// 静态内部类
private static final Singleton4 INSTANCE = new Singleton4();
}
// 构造器私有
private Singleton4() {
}
//静态工厂方法上加同步
public static final Singleton4 getInstance() {
return LazyHolder.INSTANCE;
}
}
/**
* 饿汉式单例,在类初始化时,已经自行实例化
* @author guk
*
*/
public class Singleton5 {
private Singleton5() {
}
private static final Singleton5 single = new Singleton5();
//静态工厂方法
public static Singleton5 getInstance() {
return single;
}
}