设计模式之单例模式
定义：
> 确保一个类只有一个实例，并提供一个类的全局访问点。
实现一:
> 饿汉式
>
> 类加载到内存后就实例化一个单例,通过JVM保证了线程安全,简单实用.
>
> 缺点:无论单例是否被使用,类加载时就会被实例化(......吹毛求疵)
1
2
3
4
5
6
7
8
9
| public class Sgt01 {
private static final Sgt01 INSTENCE = new Sgt01();
private Sgt01() {
}
public static Sgt01 getInstance(){
return INSTENCE;
}
}
|
实现二
> 懒汉式
>
> 实现了使用时才创建的要求
>
> 但是线程不安全
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class Sgt02 {
private static Sgt02 INSTENCE;
private Sgt02(){
}
public static Sgt02 getInstence(){
if(INSTENCE==null){
INSTENCE = new Sgt02();
}
return INSTENCE;
}
}
|
实现三
> 懒汉式加锁
>
> 解决了线程安全,但是效率变低
1
2
3
4
5
6
7
8
9
10
11
12
| public class Sgt03 {
private static Sgt03 INSTENCE;
private Sgt03(){
}
public static synchronized Sgt03 getInstence(){
if(INSTENCE==null){
INSTENCE = new Sgt03();
}
return INSTENCE;
}
}
|
实现四
> 双重检查式
>
> 尽可能的提升了加锁之后的效率
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public class Sgt04 {
private static volatile Sgt04 INSTENCE;
private Sgt04(){
}
public static synchronized Sgt04 getInstence(){
if(INSTENCE==null){
synchronized (Sgt04.class){
if(INSTENCE==null){
INSTENCE = new Sgt04();
}
}
}
return INSTENCE;
}
}
|
实现五
> 静态内部类
>
> 原理: 虚拟机在加载外部类时候不会加载内部类,只有用到是才加载,实现了懒加载
>
> 线程安全的,和饿汉式一样,是JVM保证的线程安全
1
2
3
4
5
6
7
8
9
10
11
12
| public class Sgt05 {
private Sgt05(){
}
private static class Sgt05Holder{
private final static Sgt05 INSTENCE = new Sgt05();
}
public static Sgt05 getInstance(){
return Sgt05Holder.INSTENCE;
}
}
|
实现六
> 枚举单例
>
> 不仅可以枚举单例还可以防止反序列化。
1
2
3
4
5
6
7
| public enum Sgt06 {
INSTENCE;
public void m(){};
}
|