一、饿汉式单例模式:
类型1:
/**
* 饿汉式单例(可用):使用静态常量,这会保证在类加载时
* 就初始化一个A的实例,并且避免了线程安全问题。
* 但是有可能该实例永远不会被用到而导致浪费内存。
*/
public class A {
private static final A instance = new A();
private A(){}
public A getInstance(){
return instance;
}
}
类型2:
/**
* 饿汉式单例模式(可用):跟A类型,只不过初始化自身
* 实例的过程改到静态块里面执行.
*/
public class B {
private static final B instance;
static{
instance = new B();
}
private B(){}
public B getIntance(){
return instance;
}
}
二、懒汉式单例模式:
类型1:
/**
* 懒汉式单例模式(线程不安全,多线程不可用):虽然解决了A、B
* 两种方式浪费内存的缺点,但是该方式只适用于单线程,多线程下
* 有个能出 现并发安全问题,导致创建多个实例。
*/
public class C {
private static C instance;
private C(){}
public static C getInstance(){
if(instance==null){
instance = new C();
}
return instance;
}
}
类型2:
/**
* 懒汉式单例模式(同步方法,不推荐用):解决了C中多线程并
* 发安全问题,但是效率较低,每一个想要获取该类实例的线程
* 都需要其他线程释放该方法对应的锁才能获取实例。
*/
public class D {
private static D instance;
private D(){}
private synchronized static D getInstance(){
if(instance==null){
instance = new D();
}
return instance;
}
}
类型3:
/**
* 懒汉式单例模式(同步代码块,不可用):虽然效率比D方式
* 高,但是还是存在线程安全问题。
*/
public class E {
private static E instance;
private E(){}
public static E getInstance(){
if(instance==null){
synchronized(E.class){
instance = new E();
}
}
return instance;
}
}
类型4:
/**
* 懒汉式单例模式(双重检查,推荐用):该方式既解决了饿汉式单例模式
* 可能浪费内存空间的问题,有解决了线程安全的问题,并且效率比同
* 步方法高。
*/
public class F {
private static F instance;
private F(){}
public static F getInstance(){
if(instance==null){
synchronized(F.class){
if(instance==null){
instance = new F();
}
}
}
return instance;
}
}
类型5:
/**
* 静态内部类(推荐用):整体实现是懒加载,但是里面具体的实现
* 优势利用饿汉式加载的原来(利用类加载时实例化的方式避免
* 了线程安全问题)。
*/
public class G {
private G(){}
private static class SingletonInstance{
private static final G instance = new G();
}
public static G getInstance(){
return SingletonInstance.instance;
}
}