SINGLETON—俺有6个漂亮的老婆,她们的老公都是我,我就是我们家里的老公Singleton,她们只要说道“老公”,都是指的同一个人,那就是我(刚才做了个梦啦,哪有这么好的事)
单例模式:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。
改善全局变量和命名空间的冲突,可以说是一种改良了的全局变量。这种一个类只有一个实例,且提供一个访问全局点的方式,更加灵活的保证了实例的创建和访问约束。系统中只有一个实例,因此构造方法应该为私有
饿汉式:类加载时直接创建静态实例
懒汉式:第一次需要时才创建一个实例,那么newInstance方法要加同步
饿汉式比懒汉式要好,尽管资源利用率要差。但是不用同步。
package com.modes;
/*
* 单例模式(Singleton)
*/
public class TestSingleton {
public static void main(String[] args) {
TestStream ts1 = TestStream.getInstance();
ts1.setName("Lamar");
ts1.printInfo();
TestStream ts2 = TestStream.getInstance();
ts2.setName("John");
ts1.printInfo();
ts2.printInfo();
if(ts1 == ts2){
System.out.println("创建的是同一个实例");
}else{
System.out.println("创建的不是同一个实例");
}
}
}
class TestStream {
String name = null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private TestStream(){
}
private static TestStream uniqueInstance = null;
public static TestStream getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new TestStream();
}
return uniqueInstance;
}
public void printInfo() {
System.out.println("The name is: " + name);
}
}
package com.modes;
//饿汉式单例类.在类初始化时,已经自行实例化
public class Singleton1 {
//私有的默认构造子
private Singleton1() {}
//已经自行实例化
private static final Singleton1 single = new Singleton1();
//静态工厂方法
public static Singleton1 getInstance() {
return single;
}
}
package com.modes;
//懒汉式单例类.在第一次调用的时候实例化
public class Singleton2 {
//私有的默认构造子
private Singleton2() {}
//注意,这里没有final
private static Singleton2 single=null;
//静态工厂方法
public synchronized static Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
package com.modes;
import java.util.HashMap;
import java.util.Map;
//登记式单例类.
//类似Spring里面的方法,将类名注册,下次从里面直接获取。
public class Singleton3 {
private static Map<String, Singleton3> map = new HashMap<String, Singleton3>();
static {
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保护的默认构造子
protected Singleton3(){}
//静态工厂方法,返还此类惟一的实例
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null ---> name=" + name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一个示意性的商业方法
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
//Singleton3 single3 = Singleton3.getInstance("com.modes.Singleton3");
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}
本文深入探讨了单例模式的概念及其实现方式,包括饿汉式和懒汉式的区别,并通过示例代码展示了如何确保类只有一个实例,并全局访问该实例。

被折叠的 条评论
为什么被折叠?



