在Java中实现单例设计模式的有效方法是什么？
当前回答
另一个经常用来反对单态的论点是它们的可测试性问题。出于测试目的，单体不容易被模拟。如果这是一个问题，我想做以下轻微修改：
public class SingletonImpl {
private static SingletonImpl instance;
public static SingletonImpl getInstance() {
if (instance == null) {
instance = new SingletonImpl();
}
return instance;
}
public static void setInstance(SingletonImpl impl) {
instance = impl;
}
public void a() {
System.out.println("Default Method");
}
}
添加的setInstance方法允许在测试期间设置单例类的实体模型实现：
public class SingletonMock extends SingletonImpl {
@Override
public void a() {
System.out.println("Mock Method");
}
}
这也适用于早期初始化方法：
public class SingletonImpl {
private static final SingletonImpl instance = new SingletonImpl();
private static SingletonImpl alt;
public static void setInstance(SingletonImpl inst) {
alt = inst;
}
public static SingletonImpl getInstance() {
if (alt != null) {
return alt;
}
return instance;
}
public void a() {
System.out.println("Default Method");
}
}
public class SingletonMock extends SingletonImpl {
@Override
public void a() {
System.out.println("Mock Method");
}
}
这有一个缺点，就是将此功能也暴露给普通应用程序。其他编写该代码的开发人员可能会尝试使用“setInstance”方法来更改特定函数，从而改变整个应用程序的行为，因此该方法的javadoc中至少应该包含一个良好的警告。
尽管如此，对于模型测试的可能性（当需要时），这种代码暴露可能是可以接受的代价。
其他回答
最简单的单例类：
public class Singleton {
private static Singleton singleInstance = new Singleton();
private Singleton() {}
public static Singleton getSingleInstance() {
return singleInstance;
}
}
确保你真的需要它。在谷歌上搜索“singleton反模式”，看看反对它的一些论点。
我想这并没有什么本质上的问题，但它只是一种公开某些全局资源/数据的机制，因此请确保这是最好的方法。特别是，我发现依赖注入（DI）更有用，特别是如果您也在使用单元测试，因为DI允许您将模拟资源用于测试目的。
另一个经常用来反对单态的论点是它们的可测试性问题。出于测试目的，单体不容易被模拟。如果这是一个问题，我想做以下轻微修改：
public class SingletonImpl {
private static SingletonImpl instance;
public static SingletonImpl getInstance() {
if (instance == null) {
instance = new SingletonImpl();
}
return instance;
}
public static void setInstance(SingletonImpl impl) {
instance = impl;
}
public void a() {
System.out.println("Default Method");
}
}
添加的setInstance方法允许在测试期间设置单例类的实体模型实现：
public class SingletonMock extends SingletonImpl {
@Override
public void a() {
System.out.println("Mock Method");
}
}
这也适用于早期初始化方法：
public class SingletonImpl {
private static final SingletonImpl instance = new SingletonImpl();
private static SingletonImpl alt;
public static void setInstance(SingletonImpl inst) {
alt = inst;
}
public static SingletonImpl getInstance() {
if (alt != null) {
return alt;
}
return instance;
}
public void a() {
System.out.println("Default Method");
}
}
public class SingletonMock extends SingletonImpl {
@Override
public void a() {
System.out.println("Mock Method");
}
}
这有一个缺点，就是将此功能也暴露给普通应用程序。其他编写该代码的开发人员可能会尝试使用“setInstance”方法来更改特定函数，从而改变整个应用程序的行为，因此该方法的javadoc中至少应该包含一个良好的警告。
尽管如此，对于模型测试的可能性（当需要时），这种代码暴露可能是可以接受的代价。
免责声明：我刚刚总结了所有很棒的答案，并用自己的话写了出来。
在实施Singleton时，我们有两种选择：
延迟加载早期加载
延迟加载增加了位开销（老实说，很多），所以只有当您有非常大的对象或大量的构造代码，并且有其他可访问的静态方法或字段（可能在需要实例之前使用）时，才需要使用延迟初始化。否则，选择提前加载是一个不错的选择。
实现单例的最简单方法是：
public class Foo {
// It will be our sole hero
private static final Foo INSTANCE = new Foo();
private Foo() {
if (INSTANCE != null) {
// SHOUT
throw new IllegalStateException("Already instantiated");
}
}
public static Foo getInstance() {
return INSTANCE;
}
}
一切都很好，除了它是一个早期加载的单例。让我们尝试延迟加载的单例
class Foo {
// Our now_null_but_going_to_be sole hero
private static Foo INSTANCE = null;
private Foo() {
if (INSTANCE != null) {
// SHOUT
throw new IllegalStateException("Already instantiated");
}
}
public static Foo getInstance() {
// Creating only when required.
if (INSTANCE == null) {
INSTANCE = new Foo();
}
return INSTANCE;
}
}
到目前为止还不错，但我们的英雄在与多个邪恶线程单独战斗时将无法生存，这些线程需要我们英雄的许多实例。因此，让我们保护它免受邪恶的多线程攻击：
class Foo {
private static Foo INSTANCE = null;
// TODO Add private shouting constructor
public static Foo getInstance() {
// No more tension of threads
synchronized (Foo.class) {
if (INSTANCE == null) {
INSTANCE = new Foo();
}
}
return INSTANCE;
}
}
但这还不足以保护英雄，真的！！！这是我们能/应该做的最好的事情来帮助我们的英雄：
class Foo {
// Pay attention to volatile
private static volatile Foo INSTANCE = null;
// TODO Add private shouting constructor
public static Foo getInstance() {
if (INSTANCE == null) { // Check 1
synchronized (Foo.class) {
if (INSTANCE == null) { // Check 2
INSTANCE = new Foo();
}
}
}
return INSTANCE;
}
}
这被称为“双重检查锁定习惯用法”。人们很容易忘记不稳定的说法，也很难理解为什么有必要这样做。详细信息：“双重检查锁定失败”声明
现在我们确定了邪恶的线索，但残酷的连载呢？我们必须确保即使在反序列化时也不会创建新对象：
class Foo implements Serializable {
private static final long serialVersionUID = 1L;
private static volatile Foo INSTANCE = null;
// The rest of the things are same as above
// No more fear of serialization
@SuppressWarnings("unused")
private Object readResolve() {
return INSTANCE;
}
}
方法readResolve（）将确保返回唯一的实例，即使对象在我们的程序的上一次运行中被序列化。
最后，我们添加了足够的线程和序列化保护，但我们的代码看起来又大又难看。让我们给我们的英雄一个新形象：
public final class Foo implements Serializable {
private static final long serialVersionUID = 1L;
// Wrapped in a inner static class so that loaded only when required
private static class FooLoader {
// And no more fear of threads
private static final Foo INSTANCE = new Foo();
}
// TODO add private shouting construcor
public static Foo getInstance() {
return FooLoader.INSTANCE;
}
// Damn you serialization
@SuppressWarnings("unused")
private Foo readResolve() {
return FooLoader.INSTANCE;
}
}
是的，这是我们的英雄：）
由于行private static final Foo INSTANCE=new Foo（）；仅在实际使用FooLoader类时执行，这会处理延迟实例化，并保证线程安全。
我们已经走到了今天。以下是实现我们所做一切的最佳方式：
public enum Foo {
INSTANCE;
}
内部将被视为
public class Foo {
// It will be our sole hero
private static final Foo INSTANCE = new Foo();
}
就是这样！不再担心序列化、线程和丑陋的代码。ENUMS单例也被延迟初始化。
该方法在功能上等同于公共领域方法，除了它更简洁，提供了序列化机制免费提供，并提供多重保险实例化，即使面对复杂的序列化或反射攻击。虽然这种方法尚未被广泛采用，单个元素枚举类型是实现单例的最佳方式。
-《有效的Java》中的约书亚·布洛赫
现在您可能已经意识到为什么ENUMS被认为是实现单例的最佳方式，并感谢您的耐心：）
在我的博客上更新了它。
维基百科有一些单态的例子，也在Java中。Java5实现看起来非常完整，并且是线程安全的（应用了双重检查锁定）。
推荐文章
- Eclipse调试器总是阻塞在ThreadPoolExecutor上，没有任何明显的异常，为什么?
- Java生成两个给定值之间的随机数
- 如何有效地从数组列表或字符串数组中删除所有空元素?
- 比较JUnit断言中的数组，简洁的内置方式?
- codestyle;把javadoc放在注释之前还是之后?
- 如何在Spring中定义List bean ?
- 将Set<T>转换为List<T>的最简洁的方法
- 在JavaScript中，什么相当于Java的Thread.sleep() ?
- 使用Java重命名文件
- URL从Java中的类路径加载资源
- .toArray（new MyClass[0]） or .toArray（new MyClass[myList.size（）]）？
- Hibernate中不同的保存方法之间有什么区别?
- Java 8流和数组操作
- Java Regex捕获组
- Openssl不被视为内部或外部命令
