单例模式
2019-01-31 本文已影响1人
a77118d36d9b
单例模式
保证一个类仅有一个实例(sInstance), 并提供一个访问该实例的全局访问点(getInstance).
这就意味着单例通常有如下两个特点:
- 构造函数是私有的(避免别的地方创建它)
- 有一个static的方法来对外提供一个该单例的实例.
优点：
- 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
- 避免对资源的多重占用（比如写文件操作）。
缺点：
- 没有接口，不能继承
使用场景：
- 要求生产唯一序列号。
- WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
- 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
1 饿汉式单利
饿汉式单例
顾名思义, 就是很饿, 不管三七二十一先创建了一个实例放着, 而不管最终用不用.
缺点：
- 在不需要的情况下就随便生成对象，消耗内存，不可取
2 懒汉式单例
"懒", 也就是现在懒得创建, 等有用户要用的时候才创建.
3 线程安全的懒汉式单例
利用synchronized关键字来修饰对外提供该类唯一实例的接口(getInstance)来确保在一个线程调用该接口时能阻塞(block)另一个线程的调用, 从而达到多线程安全, 避免重复创建单例.
缺点：
- synchronized有很大的性能开销. 而且在这里我们是修饰了getInstance方法, 意味着, 如果getInstance被很多线程频繁调用时, 每次都会做同步检查, 会导致程序性能下降.实际上我们要的是单例, 当单例已经存在的时候, 我们是不需要用同步方法来控制的
4 双重检查单例模式
这种方式的同步使用会减少同步锁的占用比例
缺点
- 容易出现理解错误 不加volatile 关键字引发不必要的错误
5 静态内部类单例
这种方式, 通过JVM的类加载方式(虚拟机会保证一个类的初始化在多线程环境中被正确的加锁、同步), 来保证了多线程并发访问的正确性.
另外, 由于静态内部类的加载特性 --- 在使用时才加载, 这种方式也达成了懒加载的目的.
缺点
- 完美 ，依赖于特定的语言
代码实例
package com.jack.idea.test.designmode;
/**
* 单例模式
*
* @author ljs.song
* @date 2017-12-28 15:24
*/
public class Singleton {
public static void main(String[] args) {
XiaoLong xiaoLong = new XiaoLong();
System.out.println(xiaoLong.share("小龙龙布兰妮四点分享英雄联盟王者之路和绝地求生吃鸡之秘"));
LeiLei leiLei = new LeiLei();
System.out.println(leiLei.share("磊磊四点分享英雄联盟王者之路和绝地求生吃鸡之秘"));
}
}
/**
* 小龙龙布兰妮分享
*/
class XiaoLong{
public Share share(String title){
Share share = SimpleSingleton.getInstance();
share.title(title);
return share;
}
}
/**
* 磊磊分享
*/
class LeiLei{
public Share share(String title){
Share share = SimpleSingleton.getInstance();
share.title(title);
return share;
}
}
/**
* 分享整理文件
*/
class Share{
private String title;
public void title(String title){
this.title = title;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("Share{");
sb.append("fileName : " + this.hashCode()).append(" ,");
sb.append("title='").append(title).append('\'');
sb.append('}');
return sb.toString();
}
}
/**
* 饿汉式
*/
class SimpleSingleton extends Share{
private static SimpleSingleton simpleSingleton = new SimpleSingleton();
private SimpleSingleton(){}
public static SimpleSingleton getInstance(){
return simpleSingleton;
}
}
/**
* 懒汉式（饱汉）
*/
class LazySingleton extends Share{
private static LazySingleton lazySingleton;
private LazySingleton(){}
public static LazySingleton getInstance(){
//在有人第一次分享后才创建分享的整理文件
if(lazySingleton == null){
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
//线程安全的懒汉单例 synchronized
class SynchronizedLazySingleton extends Share{
private static SynchronizedLazySingleton synchronizedLazySingleton;
private SynchronizedLazySingleton(){}
//粗鲁人也，直接锁定整个方法
public static synchronized SynchronizedLazySingleton getInstance(){
//在有人第一次分享后才创建分享的整理文件
if(synchronizedLazySingleton == null){
synchronizedLazySingleton = new SynchronizedLazySingleton();
}
return synchronizedLazySingleton;
}
}
/**
* 双重检查锁定单例
*/
class DCLLazySingleton extends Share{
/**
* 这里添加volatile 关键字是因为下面注释 问题根源 S处对象的创建
* 1.分配内存 2.初始化对象 3. 引用指向分配的地址
* 可能会出现指令重排序
* 假如 顺序变为 1,3,2 就有可能导致线程A走进S处发生重排序
* 线程B 在代码N处发现对象不为空，但是却还没初始化的尴尬
*/
private static volatile DCLLazySingleton dclLazySingleton;
private DCLLazySingleton(){}
public static DCLLazySingleton getInstance(){
//第一次检查 N
if(dclLazySingleton == null){
synchronized (DCLLazySingleton.class){
//第二次检查
if(dclLazySingleton == null) {
// 问题根源 S
dclLazySingleton = new DCLLazySingleton();
}
}
}
return dclLazySingleton;
}
}
/**
* 静态内部类单例
*/
class InnerClassSingleton{
private InnerClassSingleton(){}
public static InnerClassSingleton getInstance(){
return Inner.INNER_CLASS_SINGLETON;
}
static class Inner{
private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
}
}
