单例模式是一个比较简单的模式。
定义如下:确保某一个类只有一个实例,而且自行化实例并向整个系统提供这个实例。
单例模式的优缺点:
优点:
1、由于内存中只有一个实例,减少了内存的开销,特别是一个对象需要频繁地创建、销毁时,而且创建或销毁时性能又无法优化。
2、由于单例模式只生成一个实例,所以减少系统开销。尤其是产生需要大量的资源时,可以用过应用启动时直接产生一个单例对象,然后用驻留在内存的方式来解决。
3、可以在系统中设置全局访问,优化和共享资源访问。
缺点:
1、单例模式扩展困难,基本需要修改代码。
2、测试时不方便。
3、单例模式和单一职责原则有冲突。
单例模式的类图:
实现代码:
饿汉模式:
package com.designpatterns.singleton;
public class SingletonHungryMode {
private static final SingletonHungryMode SINGLETON = new SingletonHungryMode();
private SingletonHungryMode() {
}
public static SingletonHungryMode getSingleton(){
return SINGLETON;
}
public void sayHello() {
System.out.println("I am SingletonHungry!");
}
}
懒汉模式:
package com.designpatterns.singleton;
public class SingletonLazyMode{
private static SingletonLazyMode SINGLETON = null;
private SingletonLazyMode() {
}
public static SingletonLazyMode getSingleton(){
if(SINGLETON==null){
SINGLETON=new SingletonLazyMode();
}
return SINGLETON;
}
public void sayHello() {
System.out.println("I am SingletonLazy!");
}
}
测试用例:
package com.designpatterns.singleton;
public class Main {
public static void main(String[] args) {
SingletonHungryMode singletonHungry = SingletonHungryMode.getSingleton();
SingletonLazyMode singletonLazy = SingletonLazyMode.getSingleton();
singletonHungry.sayHello();
singletonLazy.sayHello();
}
}
但是上面的例子中,饿汉模式是线程安全的,懒汉模式是非线程安全的。
从实现方式来讲他们最大的区别就是懒汉式是延时加载。它是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建。
如果想实现懒汉模式的线程安全,那么就可以:
方法一:使用synchronized关键字修饰,代码如下:
package com.designpatterns.singleton;
public class SingletonMultiThread{
private static SingletonMultiThread SINGLETON = null;
private SingletonMultiThread() {
}
public synchronized static SingletonMultiThread getSingleton(){
if(SINGLETON==null){
SINGLETON=new SingletonMultiThread();
}
return SINGLETON;
}
public void sayHello() {
System.out.println("I am SingletonLazy!");
}
}
可以通过加同步来解决,只是加上同步效率会稍低,这时候可以使用:
方法二:双重判断来解决这个低效的问题 ,代码如下:
package com.designpatterns.singleton;
public class SingletonMultiThread2{
private static SingletonMultiThread2 SINGLETON = null;
private SingletonMultiThread2() {
}
public static SingletonMultiThread2 getSingleton(){
if(SINGLETON==null){
//加同步的时候使用的锁是 该类所属的字节码文件对象
synchronized(SingletonMultiThread2.class){
if(SINGLETON==null){
SINGLETON=new SingletonMultiThread2();
}
}
}
return SINGLETON;
}
public void sayHello() {
System.out.println("I am SingletonLazy!");
}
}
测试代码如下:
package com.designpatterns.singleton;
import java.util.HashSet;
import java.util.Set;
public class MainMT {
public static class runable implements Runnable{
public Set<SingletonMultiThread> multiThreads = new HashSet<>();
public Set<SingletonMultiThread2> multiThreads2 = new HashSet<>();
public Set<SingletonLazyMode> LazyModes = new HashSet<>();
@Override
public void run() {
SingletonMultiThread singletonMultiThread = SingletonMultiThread.getSingleton();
SingletonMultiThread2 singletonMultiThread2 = SingletonMultiThread2.getSingleton();
SingletonLazyMode singletonLazy = SingletonLazyMode.getSingleton();
multiThreads.add(singletonMultiThread);
multiThreads2.add(singletonMultiThread2);
LazyModes.add(singletonLazy);
}
}
public static void main(String[] args) {
runable run = new runable();
for (int i = 0; i < 1000; i++) {
new Thread(run).start();
}
System.out.println("i am LazyMode"+run.LazyModes);
System.out.println("i am multiThreads"+run.multiThreads);
System.out.println("i am multiThreads2"+run.multiThreads2);
}
}
测试结果如下:
i am LazyMode[com.designpatterns.singleton.SingletonLazyMode@1bf3d87, com.designpatterns.singleton.SingletonLazyMode@60991f]
i am multiThreads[com.designpatterns.singleton.SingletonMultiThread@11671b2]
i am multiThreads2[com.designpatterns.singleton.SingletonMultiThread2@12452e8]
这就是单例模式。