说白了, 单利模式, 从字面上就能理解, 就是采取一定的方法保证在整个系统中, 对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)
比如Hibernate的SessionFactory,它充当数据存储源的代理, 并负责创建Session对象, SessionFactory并不是轻量级的, 一般情况下, 一个项目通常只需要一个SessionFactory就够了,这时就会使用到单利模式
Hibernate可能现在基本用的不多了,但是Spring大家应该都用, 在Spring中, 一般声明的Bean, 如果没有特殊配置, 那么它就是单利的
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleOne {
}
/**
* 饿汉式(静态常量)
*/
class SingleOne{
// 创建静态常量
private static final SingleOne singleOne = new SingleOne();
// 私有化构造
private SingleOne(){
}
/**
* 提供一个公共静态方法
* @return 类
*/
public static SingleOne getInstance() {
return singleOne;
}
}
我感觉这没啥好测试的, 我下面就直接写代码了, 但凡做过开发的,应该都看的懂
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleTwo {
}
/**
* 饿汉式(静态代码块)
*/
class SingleTwo{
// 创建静态常量
private static final SingleTwo singletwo;
static {
singletwo = new SingleTwo();
}
// 私有化构造
private SingleTwo(){
}
/**
* 提供一个公共静态方法
* @return 类
*/
public static SingleTwo getInstance() {
return singletwo;
}
}
其实和静态常量方式,一样, 就是从直接New改到了代码块中
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleThree {
}
/**
* 懒汉式(线程不安全)
*/
class SingleThree{
// 创建静态常量
private static SingleThree singleThree;
// 私有化构造
private SingleThree(){
}
/**
* 提供一个公共静态方法
* @return 类
*/
public static SingleThree getInstance() {
if (null == singleThree) {
singleThree = new SingleThree();
}
return singleThree;
}
}
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleFour {
}
/**
* 懒汉式(线程安全, 同步方法)
*/
class SingleFour{
// 创建静态常量
private static SingleFour singleFour;
// 私有化构造
private SingleFour(){
}
/**
* 提供一个公共静态方法
* @return 类
*/
public synchronized static SingleFour getInstance() {
if (null == singleFour) {
singleFour = new SingleFour();
}
return singleFour;
}
}
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleFive {
}
/**
* 懒汉式(线程安全, 同步代码块)
*/
class SingleFive {
// 创建静态常量
private static SingleFive singleFive;
// 私有化构造
private SingleFive() {
}
/**
* 提供一个公共静态方法
*
* @return 类
*/
public static SingleFive getInstance() {
if (null == singleFive) {
// 其实还是类锁
synchronized (SingleFive.class) {
singleFive = new SingleFive();
}
}
return singleFive;
}
}
参考同步方法的步骤
将同步块放在if块的外面,然后在同步块的外面再包一层if块
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleSix {
}
/**
* 双重检查
*/
class SingleSix {
// 创建静态常量
private static volatile SingleSix singleSix;
// 私有化构造
private SingleSix() {
}
/**
* 提供一个公共静态方法
*
* @return 类
*/
public static SingleSix getInstance() {
// 再包一层if块用于卡线程, 如果有了就可以直接获取, 解决排队问题
if (null == singleSix) {
// 其实还是类锁
synchronized (SingleSix.class) {
if (null == singleSix){
singleSix = new SingleSix();
}
}
}
return singleSix;
}
}
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleSeven {
}
/**
* 双重检查
*/
class SingleSeven {
// 私有化构造
private SingleSeven() {
}
private static final class SingleSevenHolder {
// 创建静态常量
static final SingleSeven singleSeven = new SingleSeven();
}
/**
* 提供一个公共静态方法
*
* @return 类
*/
public static SingleSeven getInstance() {
// 再包一层if块用于卡线程, 如果有了就可以直接获取, 解决排队问题
// 其实还是类锁
return SingleSevenHolder.singleSeven;
}
}
package com.dance.design.designmodel.simpleinterestmodel;
public class SimpleEight {
public static void main(String[] args) {
SingleEight.INSTANCE.say();
}
}
/**
* 静态内部类
*/
enum SingleEight {
INSTANCE;
public void say(){
System.out.println("say 单利模式");
}
}
package java.lang;
import java.io.*;
import java.util.StringTokenizer;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
/**
* 第一句话就表明了这是一个单利的类
* Every Java application has a single instance of class
* .......
*/
public class Runtime {
// 声明私有的成员变量 一上来就new 所以是饿汉式(静态变量)
private static Runtime currentRuntime = new Runtime();
// 提供对外的公共静态方法
public static Runtime getRuntime() {
return currentRuntime;
}
// 私有化构造方法
/** Don't let anyone else instantiate this class */
private Runtime() {}
}