简介
所谓类的单例设计模式,就是采取一定的方法保证在整个软件系统中,对某个类 只能存在一个对象实例,并且该类之提供一个取得其对象的方法
单例设计模式的八种方式
1. 饿汉式(静态常量) ***
2. 饿汉式(静态代码块) ***
3. 懒汉式(线程不安全)
4. 懒汉式(线程安全,同步方法)
5. 懒汉式(线程安全,同步代码块)
6. 双重检查 ***
7. 静态内部类 ***
8. 枚举 ***
1. 饿汉式(静态常量) 应用实例
步骤如下:
1.构造器私有化 (防止new)
2.类的内部创建对象
3.向外暴漏一个静态的共有方法
4.代码实现
ublic class Singleton1 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
//饿汉式(静态常量) 应用实例
class Singleton{
//构造器私有化
private Singleton(){
}
//本类内部创建对象实例
private final static Singleton instance = new Singleton();
//提供公有的静态方法,返回实例对象
public static Singleton getInstance() {
return instance;
}
}
打印
cn.icanci.principle.singleton.type1.Singleton@15db9742
cn.icanci.principle.singleton.type1.Singleton@15db9742
true
优缺点说明
1.优点: 这种写法比较简单,就是在类加载的时候就去完成实例化,避免了线程同步的问题
2.缺点:在类装载的时候就完成了实例化,没有达到懒加载的效果,如果从始至终都没有使用过这个实例,那么这个实例就浪费了内存
3.这种方式基于 classloder机制避免了多线程的同步问题.不过,instance在类加载的时候就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他种方法(或者其他种静态方法)导致类装载,这个时候 就没有懒加载的效果
4.结论:这种单例模式可用,但是 可能 造成内存浪费
2. 饿汉式(静态代码块) 应用实例
- 代码演示
public class Singleton2 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
//饿汉式(静态常量) 应用实例
class Singleton{
//构造器私有化
private Singleton(){
}
//本类内部创建对象实例
private static Singleton instance ;
static{ //在静态代码块中 创建单例对象
instance = new Singleton();
}
//提供公有的静态方法,返回实例对象
public static Singleton getInstance() {
return instance;
}
}
打印
cn.icanci.principle.singleton.type2.Singleton@15db9742
cn.icanci.principle.singleton.type2.Singleton@15db9742
true
优缺点说明
- 这种方式和上面的方式其实类似,只不过将类实例化放在静态代码块,但是需要注意的是,instance的声明必须在静态代码块之前,否则可能会 为 null .其实也就是在类装载的时候,就执行静态代码块中的代码,初始化类的实例,优缺点和上面是一样的
2.结论:这种单例模式可用,但是 可能 会造成 内存的浪费
3. 懒汉式(线程不安全) 应用实例
public class Singleton3 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
class Singleton {
private Singleton() {
}
private static Singleton instance;
// 提供一个共有静态返回类对象
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点
- 优点,起到了懒加载的效果,什么时候用什么时候再加载,但是只能再单线程下使用后
- 缺点:如果在多线程情况下,一个线程进入了if(instance == null)还没有来得及向下进行,而另外一个线程也执行了这个判断语句,这个时候会产生多个实例,所以在多线程情况下不可以使用这种方式
- 总结:实际开发中不可以使用这种方式
4. 懒汉式(线程安全,同步方法) 应用实例
代码
public class Singleton4 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
class Singleton {
private Singleton() {
}
private static Singleton instance;
// 提供一个共有静态返回类对象
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
打印
cn.icanci.principle.singleton.type4.Singleton@15db9742
cn.icanci.principle.singleton.type4.Singleton@15db9742
true
优缺点说明
1.解决了线程不安全问题
2.效率太低了,每个线程在想获得类的实例的时候,执行getInstance方法都要进行同步,而其实这个方法只要执行一次实例化就足够了,后面的想获得该类的实例,直接return就可以了,方法同步效率太低
3.在实际开发中,不适用这种方式
5. 懒汉式(线程安全,同步代码块) 应用实例
代码
public class Singleton5 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
class Singleton {
private Singleton() {
}
private static Singleton instance;
// 提供一个共有静态返回类对象
public static Singleton getInstance() {
if (instance == null) {
synchronized(Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
这里看似线程安全,但是也不能保证,因为 if()的判断,和上面的类似
优缺点说明
1.这种方式,本意是相对第四种方式进行改进,因为同步代码方法的效率太低,改为同步代码块
-
但是这种同步方法并不能起到线程同步的作用,和第三种方式一样,如果在多线程情况下,一个线程进入了if(instance == null)还没有来得及向下进行,而另外一个线程也执行了这个判断语句,这个时候会产生多个实例,所以在多线程情况下不可以使用这种方式
3.结论,在实际开发中,不能使用这种方式
6. 双重检查 应用实例
代码
public class Singleton6 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
class Singleton {
private Singleton() {
}
private static volatile Singleton instance;
// 提供一个共有静态返回类对象
public static Singleton getInstance() {
if (instance == null) {
synchronized(Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
优缺点
1.Double-check概念是多线程开发中经常使用的,如代码所示,我们进行了两次if(instance== null) 判断 吗,这样就可以保证线程安全了
2.这样,实例化代码是实例化一次,后面再次访问的时候,判断 if(instance==null)就直接return 实例化对象 延迟加载,效率较高
3.线程安全,延迟加载,效率较高
4.结论:在实际开发中,推荐使用这种单例设计模式
7. 静态内部类 ***
代码演示
public class Singleton7 {
public static void main(String[] args) {
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == Singleton.getInstance());
}
}
class Singleton {
private Singleton() {
}
//静态内部类
public static class SingletonInstance{
private static final Singleton INSTANCE = new Singleton();
}
// 提供一个共有静态返回类对象
public static Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
优缺点
1.这种方式采用了类装载机制来保证初始化实例的时候只有一个线程
2.静态内部类方式在Singleton类被加载的时候并不会立即实例化,而是在需要实例化的时候,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化
3.类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮我们保证了线程的安全性,在类进行初始化的时候,别的线程是无法进入的
4.优点:避免了 线程不安全 利用静态内部类的特点实现延迟加载,效率很高
5.结论:推荐使用
8. 枚举 ***
代码
public class Singleton8 {
public static void main(String[] args) {
Singleton s = Singleton.INSTANCE;
Singleton s2 = Singleton.INSTANCE;
System.out.println(s);
System.out.println(s2);
System.out.println(s == s2);
System.out.println(Singleton.INSTANCE);
System.out.println(Singleton.INSTANCE);
System.out.println(Singleton.INSTANCE == Singleton.INSTANCE);
System.out.println(Singleton.INSTANCE.hashCode());
System.out.println(Singleton.INSTANCE.hashCode());
}
}
enum Singleton{
INSTANCE;
public void sayOK() {
System.out.println("ok");
}
}
打印
INSTANCE
INSTANCE
true
INSTANCE
INSTANCE
true
366712642
366712642
优缺点
1.借助JDK1.5中 添加的枚举来实现单例模式,不仅仅能够避免多线程同步问题,而且还可以防止发序列化重新创建生成新的对象
2.这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
3.结论:推荐使用
单例模式在JDK源码的分析
Runtime 就是单例模式饿汉式的第一种创建方式
public class Runtime {
private static Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class <code>Runtime</code> are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the <code>Runtime</code> object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
}
单例模式注意事项和细节说明
1.单例模式保证了 系统内存种只有该类的一个对象,节省了系统资源,对于一些需要频繁创建和销毁的对象,使用单例模式可以提高系统性能
2.当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
3.单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象的时候消耗过多或耗费资源过多(也就是:重量级对象) 但又是经常用到的对象,工具类对象,频繁访问数据库或文件的对象(比如数据源.session工厂等)
