各种manager
各种factory
定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式
单例模式的优点:
单例模式可以保证内存里只有一个实例,减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点,可以优化和共享资源的访问。
单例模式的缺点:
单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则。
在并发测试中,单例模式不利于代码调试。在调试过程中,如果单例中的代码没有执行完,也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则。
一、饿汉式(不管是不是用,先创建实例)
public class Mgr01 {
// private static final Mgr01 INSTANCE;
//
// static {
// INSTANCE = new Mgr01();
// } 同下面写法一样
private static final Mgr01 INSTANCE = new Mgr01();
// 构造方法设置为private,别人就无法new出对象,保证唯一入口,唯一对象
// 只能通过Mgr01.getInstance()获得对象
private Mgr01() {
}
private static Mgr01 getInstance() {
return INSTANCE;
}
public static void main(String[] args) {
Mgr01 m1 = Mgr01.getInstance();
Mgr01 m2 = Mgr01.getInstance();
// m1==m2即代表是同一个实例
System.out.println(m1 == m2);
}
}
二、懒汉式(需要时再初始化)
public class Mgr02 {
private static Mgr02 INSTANCE;
private Mgr02() {
}
private static Mgr02 getInstance() {
if (INSTANCE == null) {
INSTANCE = new Mgr02();
}
return INSTANCE;
}
}
为什么会带来线程问题,我们模拟下多线程场景看下:
public class Mgr03 {
private static Mgr03 INSTANCE;
private Mgr03() {
}
private static Mgr03 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Mgr03();
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() ->
//注意:不同实例的hashCode值是不同的
System.out.println(Mgr03.getInstance().hashCode())
).start();
}
}
}
运行结果如下:
966186071 733365800 966186071 544002391 118531371 966186071 930626000 1634218452 1650594751 1133046463 503674368 1326204679 。。。。
可以看出都是不同的实例的。
如何解决呢,我们可以在getInstance()方法前用synchronized关键词修饰,使线程同步,
public class Mgr04 {
private static Mgr04 INSTANCE;
private Mgr04() {
}
private static synchronized Mgr04 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Mgr04();
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() ->
//注意:不同实例的hashCode值是不同的
System.out.println(Mgr04.getInstance().hashCode())
).start();
}
}
}
运行结果如下:
1650373908 1650373908 1650373908 1650373908 1650373908 1650373908 。。。
可以看到都是同一实例,保证了线程的安全,不过会使性能下降。
那如何提高效率呢:
public class Mgr05 {
private static Mgr05 INSTANCE;
private Mgr05() {
}
private static Mgr05 getInstance() {
if (INSTANCE == null) {
// 试图通过减小同步代码块的方式提高效率,但是不可行
synchronized (Mgr05.class) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Mgr05();
}
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() ->
//注意:不同实例的hashCode值是不同的
System.out.println(Mgr05.getInstance().hashCode())
).start();
}
}
}
运行结果后我们发现并不可行,也是不安全的,那么我们双重上锁看看:
public class Mgr06 {
private static Mgr06 INSTANCE;
private Mgr06() {
}
private static Mgr06 getInstance() {
if (INSTANCE == null) {
// 双重检查是否为空
synchronized (Mgr06.class) {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Mgr06();
}
}
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() ->
//注意:不同实例的hashCode值是不同的
System.out.println(Mgr06.getInstance().hashCode())
).start();
}
}
}
运行结果后发现是可以的,这种方式显得有点复杂,但是确实比较完美了,但还有更完美的方式如下:
public class Mgr07 {
private Mgr07() {
}
private static class Mgr07Holder {
private static final Mgr07 INSTANCE = new Mgr07();
}
public static Mgr07 getInstance() {
return Mgr07Holder.INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() ->
//注意:不同实例的hashCode值是不同的
System.out.println(Mgr07.getInstance().hashCode())
).start();
}
}
}
总结
其实在实际开发过程中用Mgr01的方式实现单例即可,虽然有些小问题,但完全可以满足使用,如果想要吹毛求疵,写的完美,那就选择Mgr06或者Mgr07的方式了。



