1.基本介绍
所谓的单例设计模式,就是采用一定的方法保证在整个的软件系统中,对于某个类只能存在一个对象实例,并且只提供一个取得其对象实例的方法(静态方法)。比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够了,这就是使用到单例模式。
2.单例设计模式八种方式
1)饿汉式(静态常量)
2)饿汉式(静态代码块)
3)懒汉式(线程不安全)
4)懒汉式(线程安全,同步方法)
5)懒汉式(线程安全,同步代码块)
6)双重检查
7)静态内部类
8)枚举
3.1 饿汉式(静态常量)
①构造器私有化
②类内部创建一个对象
③向外暴露一个静态的公共方法。getInstance
代码实现:
public class SingletonTest1 {
public static void main(String[] args) {
Singleton singleton=Singleton.getInstance();
Singleton singleton1=Singleton.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton{
private final static Singleton instance=new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
}
优缺点说明:
①优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
②缺点:在类转载的时候就完成实例化,没有达到Lasy Loading的效果。如果从始至终从未使用这个实例,则会造成内存的浪费。
结论:这种单例模式可用,可能造成内存浪费。
3.2 饿汉式(静态代码块)
代码演示:
public class SingletonTest2{
public static void main(String[] args) {
Singleton2 singleton=Singleton2.getInstance();
Singleton2 singleton1=Singleton2.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton2{
private static Singleton2 instance;
private Singleton2(){
}
static {
instance=new Singleton2();
}
public static Singleton2 getInstance(){
return instance;
}
}
优缺点说明:这种方式和上面的方式其实是类似,只不过将实例的过程放在了静态代码块中,也是在类加载的时候,就是执行静态代码块中的代码,初始化的实例。优缺点和上面是一样的。
结论:这种单例模式可用,但是可能造成内存浪费。
3.3 懒汉式(线程不安全)
代码演示:
public class SingletonTest3{
public static void main(String[] args) {
Singleton3 singleton=Singleton3.getInstance();
Singleton3 singleton1=Singleton3.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton3{
private static Singleton3 instance;
private Singleton3(){
}
public static Singleton3 getInstance(){
if(instance==null){
new Singleton3();
}
return instance;
}
}
优缺点说明:
1)起到Lazy Loading的效果,单只能在单线程下使用。
2)如果在多线程下,一个线程进入了if(instance==null)判断语句块,还未来得及往下执行,另一个也通过了这个判断,这是便会产生多个实例。所以在多线程下不使用这种方式。
结论:在实际开发中,不要使用这种方式。
3.4 懒汉式(线程安全,同步方法)
代码演示:
public class SingletonTest4{
public static void main(String[] args) {
Singleton4 singleton=Singleton4.getInstance();
Singleton4 singleton1=Singleton4.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton4{
private static Singleton4 instance;
private Singleton4(){
}
public static synchronized Singleton4 getInstance(){
if(instance==null){
new Singleton4();
}
return instance;
}
}
优缺点说明:
1)解决了线程安全问题
2)效率太低了,每一个线程在想获得实例时候,执行getInstance()方法都要进行同步,而其实这个方法只执行一次实例化就够了,后面想获得该实例,直接return就行了。方法进行同步效率太低。
结论:在实际开发中,不推荐使用这种方式。
3.5 懒汉式(线程安全,同步代码块)
代码演示
public class SingletonTest5{
public static void main(String[] args) {
Singleton5 singleton=Singleton5.getInstance();
Singleton5 singleton1=Singleton5.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton5{
private static Singleton5 instance;
private Singleton5(){
}
public static Singleton5 getInstance(){
if(instance==null){
synchronized (Singleton.class){
new Singleton5();
}
}
return instance;
}
}
这个方式没有解决线程安全问题,不推荐使用。
3.6 双重检查
代码演示:
public class SingletonTest6{
public static void main(String[] args) {
Singleton6 singleton=Singleton6.getInstance();
Singleton6 singleton1=Singleton6.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton6{
private static Singleton6 instance;
private Singleton6(){
}
public static Singleton6 getInstance(){
if(instance==null)
synchronized (Singleton.class){
if(instance==null){
new Singleton6();
}
}
return instance;
}
}
优缺点说明:
1)双重检查时多线程开发中常用到的,如代码中所示,我们进行了两次if(instance==null)检查,这样就可以保证线程安全了。
2)这样,实例化代码只用了一次,后面再次访问时,判断if(instance==null),直接return实例化对象,也避免的反复进行方法同步。
3)线程安全:延迟加载:效率高。
结论:在实际开发,推荐使用这种单例设计模式。
3.7 静态内部类
代码演示
public class SingletonTest7 {
public static void main(String[] args) {
Singleton7 singleton=Singleton7.getInstance();
Singleton7 singleton1=Singleton7.getInstance();
System.out.println(singleton==singleton1);
}
}
class Singleton7{
private Singleton7(){
}
public static class SingletonInstance{
private static final Singleton7 SINGLETON_7=new Singleton7();
}
public static synchronized Singleton7 getInstance(){
return SingletonInstance.SINGLETON_7;
}
}
优缺点说明:
①这种方式采用了类装载的机制保证初始化实例时只有一个线程。
②静态内部类方式在Singleton7类装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingleInstance类,从而完成Singleton的实例化。
③类的静态属性只会在第一次加载类的时候初始化,所以在这里,jvm帮助我们保证了线程的安全性,在类进行初始化时,别的线程无法进入的。
④优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高。
结论:推荐使用。
3.8 枚举
代码演示:
ublic class SingletonTest8 {
public static void main(String[] args) {
Sinleton8 instance = Sinleton8.INSTANCE;
Sinleton8 instance1 = Sinleton8.INSTANCE;
System.out.println(instance==instance1);
instance.sayOk();
}
}
enum Sinleton8{
INSTANCE ;// 属性
public void sayOk(){
System.out.println("ok~~~~~");
}
}
优缺点说明:
1)这是借助JDK1.5中添加的枚举实例来实现单例模式。不仅能避免线程同步问题,而且还能防止反序列化重新创建新的对象。
结论:推荐使用。