单例模式
2015-12-17 16:07
253 查看
单例模式(Singleton)
理论啥的就不自己说了,去网上抄一个。
单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。这样的模式有几个好处:
1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类:
输出:
这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,多线程测试如下
为了模拟多线程的情况,我们在获取单例的时候设定一个5秒的延迟,就会发现最终创建了两次对象,运行结果如下
这不是我们想要的结果。
然后,我们加入了锁“synchronized”
如果对“synchronized”不了解的同学可以先看看这里
/article/9197427.html
这里大家一定要注意synchronized(对象)的时候,对象不能为null不然会报空指针的错误。运行结果如下
可以看出加了锁synchronized之后,也只创建了一个,达到了我们的要去。
接来下又要开始copy了
实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:
运行结果:
继续copy文字
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:
补充:采用”影子实例”的办法为单例对象的属性同步更新
这里我也没看出具体作用的,知道的大神麻烦告诉下。
结尾copy
通过单例模式的学习告诉我们:
1、单例模式理解起来简单,但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。
到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?
首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)
其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。
再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。
最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!
理论啥的就不自己说了,去网上抄一个。
单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。这样的模式有几个好处:
1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类:
package com.designPatterns.Singleton.Singleton; public class Singleton { /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */ private static Singleton instance = null; /* 私有构造方法,防止被实例化 */ private Singleton() { } /* 静态工程方法,创建实例 */ public static Singleton getInstance(String msg) throws InterruptedException{ System.out.println("开始静态工程方法,创建实例 ."+msg); if (instance == null) { //Thread.sleep(5000); System.out.println("创建."+msg); instance = new Singleton(); } System.out.println("结束静态工程方法,创建实例."+msg); return instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve() { return instance; } /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { Singleton.getInstance("main测试1"); Singleton.getInstance("main测试2"); // TestThread testThread = new TestThread(); // TestThread testThread2 = new TestThread(); // testThread.start(); // testThread2.start(); } public static class TestThread extends Thread{ @Override public void run() { try { Singleton.getInstance("2"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
输出:
开始静态工程方法,创建实例 .main测试1 创建.main测试1 结束静态工程方法,创建实例.main测试1 开始静态工程方法,创建实例 .main测试2 结束静态工程方法,创建实例.main测试2
这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,多线程测试如下
package com.designPatterns.Singleton.Singleton; public class Singleton { /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */ private static Singleton instance = null; /* 私有构造方法,防止被实例化 */ private Singleton() { } /* 静态工程方法,创建实例 */ public static Singleton getInstance(String msg) throws InterruptedException{ System.out.println("开始静态工程方法,创建实例 ."+msg); if (instance == null) { Thread.sleep(5000);//这里的5秒延迟,是为了测试多线程的时候用的,模拟两个线程同时进入这个方法引起的问题。 System.out.println("创建."+msg); instance = new Singleton(); } System.out.println("结束静态工程方法,创建实例."+msg); return instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve() { return instance; } /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { // Singleton.getInstance("main测试1"); // Singleton.getInstance("main测试2"); TestThread testThread = new TestThread(); TestThread testThread2 = new TestThread(); testThread.start(); testThread2.start(); } public static class TestThread extends Thread{ @Override public void run() { try { Singleton.getInstance("2"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
为了模拟多线程的情况,我们在获取单例的时候设定一个5秒的延迟,就会发现最终创建了两次对象,运行结果如下
开始静态工程方法,创建实例 .2 开始静态工程方法,创建实例 .2 创建.2 创建.2 结束静态工程方法,创建实例.2 结束静态工程方法,创建实例.2
这不是我们想要的结果。
然后,我们加入了锁“synchronized”
如果对“synchronized”不了解的同学可以先看看这里
/article/9197427.html
public class SingletonThread { /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */ private static SingletonThread instance = null; /* 私有构造方法,防止被实例化 */ private SingletonThread() { // try { // System.out.println("进入八秒休眠"); // Thread.sleep(8000); // } catch (InterruptedException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } } /* 静态工程方法,创建实例 */ public static synchronized SingletonThread getInstance(String msg){ System.out.println("开始静态工程方法,创建实例 ."+msg); if (instance == null) { // synchronized (instance) { //这里这样写会报空指针错误 if (instance == null) { System.out.println("创建单例."+msg); instance = new SingletonThread(); System.out.println("创建单例完毕."+msg); } // } } System.out.println("结束静态工程方法,创建实例."+msg); return instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve() { return instance; } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub // Singleton singleton = new Singleton(); // singleton.getInstance(); ThreadTestA threadTestA = new ThreadTestA(); ThreadTestB threadTestB = new ThreadTestB(); threadTestA.start(); threadTestB.start(); } public static class ThreadTestA extends Thread{ @Override public void run() { SingletonThread.getInstance("ThreadTestA"); } } public static class ThreadTestB extends Thread{ @Override public void run() { SingletonThread.getInstance("threadTestB"); } } }
这里大家一定要注意synchronized(对象)的时候,对象不能为null不然会报空指针的错误。运行结果如下
开始静态工程方法,创建实例 .ThreadTestA 创建单例.ThreadTestA 创建单例完毕.ThreadTestA 结束静态工程方法,创建实例.ThreadTestA 开始静态工程方法,创建实例 .threadTestB 结束静态工程方法,创建实例.threadTestB
可以看出加了锁synchronized之后,也只创建了一个,达到了我们的要去。
接来下又要开始copy了
实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:
public class SingletonInnerClass { /* 私有构造方法,防止被实例化 */ private SingletonInnerClass() { System.out.println("创建了一次"); } /* 内部类维护单例 */ private static class SingletonFactory{ private static SingletonInnerClass instance = new SingletonInnerClass(); } /* 静态工程方法,创建实例 */ public static SingletonInnerClass getInstance(String msg) { System.out.println("开始静态工程方法,创建实例 ."+msg); return SingletonFactory.instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve() { return getInstance("readResolve"); } /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { // Singleton.getInstance("main测试1"); // Singleton.getInstance("main测试2"); TestThread testThread = new TestThread(); TestThread testThread2 = new TestThread(); testThread.start(); testThread2.start(); } public static class TestThread extends Thread{ @Override public void run() { SingletonInnerClass.getInstance("2"); } } }
运行结果:
开始静态工程方法,创建实例 .2 开始静态工程方法,创建实例 .2 创建了一次
继续copy文字
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:
补充:采用”影子实例”的办法为单例对象的属性同步更新
public class SingletonProperties { private static SingletonProperties instance = null; private Vector properties = null; public Vector getProperties() { return properties; } public static synchronized void syncInit(){ if (instance == null) { instance = new SingletonProperties(); } } /* 静态工程方法,创建实例 */ public static SingletonProperties getInstance(String msg) { if (instance == null) { syncInit(); } return instance; } public void updateProperties() { SingletonProperties shadow = new SingletonProperties(); properties = shadow.getProperties(); } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub } }
这里我也没看出具体作用的,知道的大神麻烦告诉下。
结尾copy
通过单例模式的学习告诉我们:
1、单例模式理解起来简单,但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。
到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?
首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)
其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。
再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。
最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!
相关文章推荐
- 圣诞来了 h5游戏风靡朋友圈了
- Java注册邮箱激活验证实现代码
- iOS 3DES加密解密(一行代码搞定)
- Android中软键盘弹出时底部菜单上移问题
- (转)【Unity3d】Glow + Outline 轮廓描边
- ios学习--获取通过UIImagePackerController获取的系统相册 图片&视频 的名称信息
- android WebView 提升网页打开速度
- mongodb conf 文件
- oracle存储过程continue
- selenium WebDriver 对浏览器标签页的切换
- IOS开发之——绘图(CGContext)
- 深入浅出 RPC - 深入篇
- Android 干货集
- You need to use a Theme.AppCompat theme (or descendant) with this activity.
- 一个小小的购物车系统
- Android 自动化测试——Monkey测试
- 开发数据库篇—FMDB数据库队列
- 源码探索系列5---关于Broadcast、LocalBroadcastManager 、EventBus的比较和源码解析
- 安装salt客户端出现错误
- 编程成长日记――杨辉三角