单例模式: 指一个类只有一个实例,且该类能自行创建这个实例的一种模式。
单例模式的用途:
1. 一个类只生成一个对象,可以节省内存资源、保证数据内容的一致性,避免出现当某类需要频繁实例化,而创建的对象又频繁被销毁的情况。
2. 适用于对象需要被共享的场合。共享对象可以有效节省内存,提高访问效率。
单例模式可以分为懒汉模式和饿汉模式:
class Singleton{
private static volatile Singleton single;
private static Singleton(){}
public static synchronized Singleton getInstance(){
if(single == null)
single =new Singleton();
return single;
}
}
这是懒汉模式,只有当第一次调用getInstance()的时候才会初始化对象,可以避免浪费内存;但是加锁降低了执行效率。
class SingleObj{
//私有变量
private static SingleObj single=new SingleObj();
//私有构造函数 不能被实例化
private static SingleObj(){}
public static SingleObj getInstance(){
return single;
}
}
这是饿汉模式,其特点是类加载的时候就初始化,执行效率高(没有锁),但有时会出现从来没用过的情况,这样会浪费内存。
这里可能有人会想,有没有一种即高效又安全,避免浪费内存的方法呢。这就是双重锁判读机制:
/**
*Double CheckLock实现单例
*/
public class SingletonThree {
private volatile static SingletonThree instance;
//私有化构造器
private SingletonThree() {
}
//双重锁判断机制
public static SingletonThree newInstance() {
if (instance== null) {
synchronized (SingletonThree.class) {
if (instance== null) {
instance= new SingletonThree();
}
}
}
return instance;
}
}
这是懒汉模式的一种改进,高效且安全,由于JVM底层模型原因,偶尔会出问题,不建议使用。
既然这种方法不可靠,于是便有了另外的方法(利用静态内部类实现):
/**
*静态内部类实现模式
*/
public class SingletonFour {
// 静态内部类
private static class SingletonClassInstance {
private static final SingletonFour instance= new SingletonFour();
}
// 私有化构造器
private SingletonFour() {
}
//静态工厂方法
public static SingletonFour getInstance() {
return SingletonClassInstance.instance;
}
}
利用静态内部类实现即安全又高效,有满足延时加载。
还有一种单例模式的优化方式(枚举实现):
public class SingletonFive {
//私有化构造器
private SingletonFive(){
}
//使用枚举
private static enum Singleton{
INSTANCE;
private SingletonFive singleton;
//JVM会保证此方法绝对只调用一次
private Singleton(){
singleton = new SingletonFive();
}
public SingletonFive getInstance(){
return singleton;
}
}
//静态工厂方法
public static SingletonFive getInstance(){
return Singleton.INSTANCE.getInstance();
}
}
这种方式线程安全,调用效率高,不能延时加载,可以天然的防止反射和反序列化调用,自动支持序列化机制,绝对防止多次实例化 。
{{ cmt.username }}
{{ cmt.content }}
{{ cmt.commentDate | formatDate('YYYY.MM.DD hh:mm') }}