1.什么是单例模式
2.单例模式在项目中的使用
3.有哪些实现方式
实现单例模式的要点是 1.私有化构造方法 2.指向自己实例的私有静态引用 3.以自己实例为返回值的静态公有方法
实现方式有:延迟加载(懒汉) 与 立即加载(恶汉),区别就是是否用到时候再实例化
先来了解一下懒汉式
//懒汉式的写法
class Singleton{
//私有化构造函数
private LazySingleton(){
}
//利用静态变量
private static final Singleton Singleton = new Singleton();
//对外开放一个获取对象的方法
public static Singleton getInstance(){
return Singleton;
}
}
静态变量在类加载的时候就构建完成,而类加载是按需加载,并且只是加载一次,类加载是现成安全的,所以上面的代码是线程安全的,并且单例。
public class Singleton {
public static void main(String[] args) {
// TODO Auto-generated method stub
boolean flag = LazySingleton.getInstance() == LazySingleton
.getInstance();
System.err.println(flag);
}
}
// 懒汉式的写法
class LazySingleton {
// 私有化构造函数
private LazySingleton() {
}
// 利用静态变量
private static final LazySingleton lazySingleton = new LazySingleton();
// 对外开放一个获取对象的方法
public static LazySingleton getInstance() {
return lazySingleton;
}
}
// 饿汉式
class Singleton2 {
private Singleton2() {
}
// 先不实例化对象
private static Singleton2 singleton2;
// 返回对象的时候判断是否为空,若为空就实例化
public Singleton2 getInstance() {
// 在多线程的情况下,下面if中的代码可能会发生线程安全问题,可能会有多个线程通过该if的判断
// 可在方法声明加上syncchonized,但是效率比较低下
if (singleton2 == null) {
singleton2 = new Singleton2();
}
return singleton2;
}
}
// 双重检查锁模式
class Singleton3 {
// 用volatitle修饰 保证可见性 与禁止指令重排序
private static volatile Singleton3 singleton3;
private Singleton3() {
}
public static Singleton3 getInstance() {
if (singleton3 == null) {
synchronized (Singleton3.class) {
// 分配对象的过程中有以下三个步骤,使用 volatitle
// memory = allocate(); //1:分配对象的内存空间
// ctorInstance(memory); //2:初始化对象
// /singleton3 = memory; //3:使singleton3指向刚分配的内存地址
singleton3 = new Singleton3();
}
}
return singleton3;
}
}
//静态内部类的形式
//线程安全 且 懒加载
class Singleton4{
//静态内部类的特点 外部类加载的时候 内部类不会被加载, 只有使用到的使用才会被加载, 而且只会加载一次 (类加载是线程安全的)
private static class SingletonInner{
private static final Singleton4 Instance = new Singleton4();
}
private static synchronized Singleton4 getInstance(){
return SingletonInner.Instance;
}
}