下面展示的是单例对象的创建。
public class Map_en_US extends mapTree {
private static Map_en_US m_instance;
private Map_en_US() {}
static{
m_instance = new Map_en_US();
m_instance.init();
}
public static Map_en_US getInstance(){
return m_instance;
}
@Override
protected void init() {
//some code;
}
}
我的问题是使用静态块进行实例化的原因是什么。我熟悉单例的以下实例化方式。
public static Map_en_US getInstance(){
if(m_instance==null)
m_instance = new Map_en_US();
}
原因是线程安全。
你所说的那种形式可能会多次初始化单例，并且即使已多次初始化，不同线程对getInstance()的后续调用也可能返回不同的实例！此外，一个线程可能会看到部分初始化的单例实例！（假设构造函数连接到数据库并进行身份验证；即使在构造函数中执行身份验证，一个线程也可能在其完成之前就能获得对单例的引用！）
处理线程时存在一些困难：
您应该学习这些困难，以确切地了解为什么这些奇怪的行为在JVM中是完全合法的，为什么它们实际上是好的，并且如何保护自己免受它们的影响。
静态块由JVM保证只会被执行一次（除非使用不同的ClassLoader加载和初始化类，但细节超出了这个问题的范围），并且只由一个线程执行，并且它的结果保证对每个其他线程可见。
这就是为什么你应该在静态块中初始化单例。
上面的模式将在第一次执行看到对Map_en_US类的引用时实例化单例（实际上，只有对类本身的引用将加载它，但可能尚未初始化它；有关详细信息，请检查引用）。也许你不想要那样。也许你只想在第一次调用Map_en_US.getInstance()时初始化单例（就像你所说的那个模式所做的那样）。
如果您想要这样做，可以使用以下模式：
public class Singleton {
private Singleton() { ... }
private static class SingletonHolder {
private static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
上面的代码中，只有当类SingletonHolder被初始化时，单例才会被实例化。这只会发生一次（除非，正如我之前所说，您使用多个类加载器），代码将由一个线程执行，结果不会有可见性问题，并且初始化只会在第一次引用SingletonHolder时发生，它发生在getInstance()方法内部。这是我需要单例时最常用的模式。
synchronized getInstace()如本答案评论中讨论的那样，有另一种以线程安全方式实现单例的方法，几乎与您熟悉的（有缺陷的）方法相同：
public class Singleton {
private static Singleton instance;
public static synchronized getInstance() {
if (instance == null)
instance = new Singleton();
}
}
以上代码是通过内存模型来保证线程安全的。JVM规范以更加晦涩的方式陈述了以下内容：假设L是任何对象的锁，T1和T2是两个线程。T1释放L的操作发生在T2获取L的操作之前。
这意味着，在释放锁之前，T1进行的所有操作都将对其他线程可见，这些线程在获取相同锁后都能看到。
因此，假设T1是第一个进入getInstance()方法的线程。在它完成之前，没有其他线程能够进入相同的方法（因为它被同步了）。它将看到instance为null，将创建一个Singleton实例并存储在字段中。然后，它会释放锁并返回该实例。
接下来，等待锁的T2将能够获取并进入该方法。由于它获取了T1刚刚释放的相同锁，T2将看到字段instance包含由T1创建的Singleton的完全相同的实例，并简单地返回它。更重要的是，由T1完成的单例初始化发生在T1释放锁之前，T1释放锁发生在T2获取锁之前，因此T2不会看到部分初始化的单例。
以上代码是完全正确的。唯一的问题是对单例的访问将被序列化。如果它经常发生，它将降低应用程序的可扩展性。这就是为什么我更喜欢我上面展示的SingletonHolder模式：可以真正并发地访问单例，而无需同步！
通常，人们担心锁获取的成本。我读过现在它对大多数应用程序来说不那么重要。锁获取的真正问题是通过序列化对同步块的访问来损害可扩展性。
有人想出了一个聪明的方法来避免获取锁，并称之为双重检查锁定。问题是，大多数实现都是有缺陷的。也就是说，大多数实现不是线程安全的（即与原始问题中的getInstace()方法一样不安全）。
实现DCL的正确方法如下：
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
volatile关键字。要理解为什么，让T1和T2成为两个线程。首先假设该字段不是volatile的。T1进入getInstace()方法，它是第一个进入该方法的线程，因此该字段为null。然后它进入同步块，然后进入第二个if。它也计算为true，因此T1创建单例的新实例并将其存储在字段中。锁定随后被释放，并返回单例。对于这个线程来说，保证单例完全初始化。现在，T2进入getInstace()方法。它可能（虽然不一定）看到instance！= null。然后它将跳过if块（因此它永远不会获得锁），并直接返回单例。由于重排序，T2可能无法看到单例构造函数中执行的所有初始化！重新访问db连接单例示例，T2可能会看到已连接但尚未进行身份验证的单例！建议阅读Java Concurrency in Practice和Java Language Specification获取更多信息。private static Map_en_US s_instance = new Map_en_US() {{init();}};
它做的事情相同，但更加整洁。
这个语法的解释：
外部一组大括号创建了一个匿名类。
内部一组大括号称为“实例块”——在构造期间触发。
通常那些不理解正在发生什么的人会错误地将此语法称为“双括号初始化器”语法。
另外，请注意：
m_是用于实例（即成员）字段的命名约定前缀。
s_是用于类（即静态）字段的命名约定前缀。
因此，我将该字段的名称更改为s_...。
Map_en_US是final的情况下无法编译。 - ThomasMap_en_US的匿名类。因此，为了使这段代码工作，Map_en_US不能被标记为final。 - Bruno Reisinit 函数呢？ - user85421如果您在getInstance()方法中初始化，可能会出现竞争条件，即如果2个线程同时执行if(m_instance == null)检查，两者都可能看到实例为空，因此两者都可能调用m_instance = new Map_en_US();
由于静态初始化块仅由执行类加载器的一个线程执行一次，因此您在那里没有问题。
ThreadLocal），因此在变量初始化后，每次调用都应该返回相同的实例，不是吗？因此假设两个线程在初始化之后调用getInstance()，在这种情况下可能会返回不同的实例（通过在同一类实例上调用它，因此在这里没有类加载问题）？ - ThomasThreadLocal还是不是）。有时它们会与主内存同步（ThreadLocal好像没有同步到主内存）。您可以使用synchronized或volatile强制同步。如果没有同步，JVM可以随意刷新变量的本地工作副本内容到主内存中（行为取决于实现）。因此，调用getInstance（）的两个不同线程可能永远无法看到其他线程创建的实例！ - Bruno Reis静态块在这里允许进行init调用。其他编码方式可能是像这样（哪种更好是个人口味的问题）
public class Map_en_US extends mapTree {
private static
/* thread safe without final,
see VM spec 2nd ed 2.17.15 */
Map_en_US m_instance = createAndInit();
private Map_en_US() {}
public static Map_en_US getInstance(){
return m_instance;
}
@Override
protected void init() {
//some code;
}
private static Map_en_US createAndInit() {
final Map_en_US tmp = new Map_en_US();
tmp.init();
return tmp;
}
}
更新 根据VM规范2.17.5进行了更正，详见评论
// Best way to implement the singleton class in java
package com.vsspl.test1;
class STest {
private static STest ob= null;
private STest(){
System.out.println("private constructor");
}
public static STest create(){
if(ob==null)
ob = new STest();
return ob;
}
public Object clone(){
STest obb = create();
return obb;
}
}
public class SingletonTest {
public static void main(String[] args) {
STest ob1 = STest.create();
STest ob2 = STest.create();
STest ob3 = STest.create();
System.out.println("obj1 " + ob1.hashCode());
System.out.println("obj2 " + ob2.hashCode());
System.out.println("obj3 " + ob3.hashCode());
STest ob4 = (STest) ob3.clone();
STest ob5 = (STest) ob2.clone();
System.out.println("obj4 " + ob4.hashCode());
System.out.println("obj5 " + ob5.hashCode());
}
}
-------------------------------- OUT PUT -------------------------------------
private constructor
obj1 1169863946
obj2 1169863946
obj3 1169863946
obj4 1169863946
obj5 1169863946
这取决于init方法的资源密集程度。如果它需要大量工作，也许您希望在应用程序启动时完成该工作，而不是在第一次调用时完成。也许它会从互联网下载地图？我不知道...
静态块在JVM首次加载类时执行。正如Bruno所说，这有助于线程安全，因为不存在两个线程会争夺同一个getInstance()调用的可能性。
静态块实例化你的类并调用默认构造函数（如果有）仅一次，当应用程序启动并且JVM加载所有静态元素时。
使用getInstance()方法时，类的对象在调用该方法时构建和初始化，而不是在静态初始化时进行。如果您在同时运行getInstance()的不同线程中，则不是真正安全的。
有趣，以前从未见过。似乎主要是一种风格偏好。我想一个区别是：静态初始化发生在VM启动时，而不是在第一次请求实例时，可能消除了并发实例化的问题？（这也可以通过synchronized getInstance()方法声明来处理）
main(...) { System.out.println("bye"); }，它不使用类 Singleton。因此，JVM 没有必要加载类 Singleton。因此它不会被初始化。 - Bruno Reis
getInstance方法线程安全吗？！ - GrubergetInstance()声明为synchronized，内存模型将保证单例的线程安全性：不会有并发初始化，并且如果 L 是任何对象的锁，T1 和 T2 是两个线程，则 T2 获取 L happens-before T1 释放 L，因此 T2 将看到持有单例的字段已填充，并且 Singleton 的构造函数已经对两个线程完成了执行。我会在我的答案中评论这一点。 - Bruno ReisgetInstance()方法同步会引入一些同步开销。这可以通过“双重检查锁定”来大幅减少 - 请查看我的回答中的链接。 - Thomasvolatile；如果不是volatile，那么它必然是有问题的。 - Bruno Reis