所谓单例模式，简单来说，就是在整个应用中保证只有一个类的实例存在。就像是Java Web中的application，也就是提供了一个全局变量，用处相当广泛，比如保存全局数据，实现全局性的操作等。
首先，能够想到的最简单的实现是，把类的构造函数写成private的，从而保证别的类不能实例化此类，然后在类中提供一个静态的实例并能够返回给使用者。这样，使用者就可以通过这个引用使用到这个类的实例了。
饿汉式
public class SingletonClass {
private static final SingletonClass instance = new SingletonClass();
public static SingletonClass getInstance() {
return instance;
}
private SingletonClass() {
}
}
如上例，外部使用者如果需要使用SingletonClass的实例，只能通过getInstance()方法，并且它的构造方法是private的，这样就保证了只能有一个对象存在。
2. 性能优化——lazy loaded
上面的代码虽然简单，但是有一个问题——无论这个类是否被使用，都会创建一个instance对象。如果这个创建过程很耗时，比如需要连接10000次数据库(夸张了…:-))，并且这个类还并不一定会被使用，那么这个创建过程就是无用的。怎么办呢？ 为了解决这个问题，我们想到了新的解决方案：
懒汉式
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
}
private SingletonClass() {
}
}
代码的变化有两处——首先，把instance初始化为null，直到第一次使用的时候通过判断是否为null来创建对象。因为创建过程不在声明处，所以那个final的修饰必须去掉。
我们来想象一下这个过程。要使用SingletonClass，调用getInstance()方法。第一次的时候发现instance是null，然后就新建一个对象，返回出去；第二次再使用的时候，因为这个instance是static的，所以已经不是null了，因此不会再创建对象，直接将其返回。
这个过程就成为lazy loaded，也就是迟加载——直到使用的时候才进行加载。
3. 同步
上面的代码很清楚，也很简单。然而就像那句名言：“80%的错误都是由20%代码优化引起的”。单线程下，这段代码没有什么问题，可是如果是多线程，麻烦就来了。我们来分析一下：
线程A希望使用SingletonClass，调用getInstance()方法。因为是第一次调用，A就发现instance是null的，于是它开始创建实例，就在这个时候，CPU发生时间片切换，线程B开始执行，它要使用SingletonClass，调用getInstance()方法，同样检测到instance是null——注意，这是在A检测完之后切换的，也就是说A并没有来得及创建对象——因此B开始创建。B创建完成后，切换到A继续执行，因为它已经检测完了，所以A不会再检测一遍，它会直接创建对象。这样，线程A和B各自拥有一个SingletonClass的对象——单例失败！
解决的方法也很简单，那就是加锁：
public class SingletonClass {
private static SingletonClass instance = null;
public synchronized static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
private SingletonClass() {
}
}
是要getInstance()加上同步锁，一个线程必须等待另外一个线程创建完成后才能使用这个方法，这就保证了单例的唯一性。
4. 又是性能
上面的代码又是很清楚很简单的，然而，简单的东西往往不够理想。这段代码毫无疑问存在性能的问题——synchronized修饰的同步块可是要比一般的代码段慢上几倍的！如果存在很多次getInstance()的调用，那性能问题就不得不考虑了！
让我们来分析一下，究竟是整个方法都必须加锁，还是仅仅其中某一句加锁就足够了？我们为什么要加锁呢？分析一下出现lazy loaded的那种情形的原因。原因就是检测null的操作和创建对象的操作分离了。如果这两个操作能够原子地进行，那么单例就已经保证了。于是，我们开始修改代码：
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
return instance;
}
private SingletonClass() {
}
}
首先去掉getInstance()的同步操作，然后把同步锁加载if语句上。但是这样的修改起不到任何作用：因为每次调用getInstance()的时候必然要同步，性能问题还是存在。如果……如果我们事先判断一下是不是为null再去同步呢？
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) { //（位置a）
synchronized (SingletonClass.class) {
if (instance == null) { //（位置b）
instance = new SingletonClass(); //（位置c）
}
}
return instance;
}
private SingletonClass() {
}
}
还有问题吗？首先判断instance是不是为null，如果为null，加锁初始化；如果不为null，直接返回instance。
这就是double-checked locking设计实现单例模式。到此为止，一切都很完美。我们用一种很聪明的方式实现了单例模式。
5. 从源头检查
下面我们开始说编译原理。所谓编译，就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。针对Java，它的目标代码不是本地机器代码，而是虚拟机代码。编译原理里面有一个很重要的内容是编译器优化。所谓编译器优化是指，在不改变原来语义的情况下，通过调整语句顺序，来让程序运行的更快。这个过程成为reorder。
要知道，JVM只是一个标准，并不是实现。JVM中并没有规定有关编译器优化的内容，也就是说，JVM实现可以自由的进行编译器优化。
下面来想一下，创建一个变量需要哪些步骤呢？一个是申请一块内存，调用构造方法进行初始化操作，另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢？JVM规范并没有规定。那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化。
如上所述的的内存模型，假如线程A已经把instance指向了那块内存，只是还没有调用构造方法（在位置c运行，但只完成了部分，但是instance不为null），而此时线程B（假如运行到位置a）检测到instance不为null，于是直接把instance返回了。
——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了！
于是，我们想到了下面的代码：
public class SingletonClass {
private static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) {
SingletonClass sc;
synchronized (SingletonClass.class) {
sc = instance;
if (sc == null) {
synchronized (SingletonClass.class) {
if(sc == null) {
sc = new SingletonClass();
}
}
instance = sc;
}
}
}
return instance;
}
private SingletonClass() {
}
}
我们在第一个同步块里面创建一个临时变量，然后使用这个临时变量进行对象的创建，并且在最后把instance指针临时变量的内存空间。写出这种代码基于以下思想，即synchronized会起到一个代码屏蔽的作用，同步块里面的代码和外部的代码没有联系。因此，在外部的同步块里面对临时变量sc进行操作并不影响instance，所以外部类在instance=sc;之前检测instance的时候，结果instance依然是null。
不过，这种想法完全是错误的！同步块的释放保证在此之前——也就是同步块里面——的操作必须完成，但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此，编译器完全可以把instance=sc;这句移到内部同步块里面执行。这样，程序又是错误的了！
6. 解决方案
说了这么多，难道单例没有办法在Java中实现吗？其实不然！
在JDK 5之后，Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整！因此，只要我们简单的把instance加上volatile关键字就可以了。简单地讲，volatile保证了变量构造过程的原子性。
public class SingletonClass {
private volatile static SingletonClass instance = null;
public static SingletonClass getInstance() {
if (instance == null) {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass() {
}
}
然而，这只是JDK1.5之后的Java的解决方案，那之前版本呢？其实，还有另外的一种解决方案，并不会受到Java版本的影响：
public class SingletonClass {
private static class SingletonClassInstance {
private static final SingletonClass instance = new SingletonClass();
}
public static SingletonClass getInstance() {
return SingletonClassInstance.instance;
}
private SingletonClass() { }
}
}
在这一版本的单例模式实现代码中，我们使用了Java的静态内部类。这一技术是被JVM明确说明了的，因此不存在任何二义性。在这段代码中，因为SingletonClass没有static的属性，因此并不会被初始化。直到调用getInstance()的时候，会首先加载SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用SingletonClass的构造方法，然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是static的，因此并不会构造多次。
由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。
饿汉式单例类可以在Java 语言内实现，但不易在C++ 内实现，因为静态初始化在C++ 里没有固定的顺序，因而静态变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么GoF 在提出单例类的概念时，举的例子是懒汉式的。他们的书影响之大，以致Java 语言中单例类的例子也大多是懒汉式的。实际上，饿汉式单例类可能更符合Java 语言本身的特点。
相关推荐
单例模式是软件设计模式中的一种经典模式，用于确保一个类只有一个实例，并提供一个全局访问点。...通过学习和实践这些单例模式的实现，我们可以更好地理解和应用设计模式，提升代码的质量和可维护性。
Java单例模式是一种设计模式，它允许...以上就是关于Java单例模式的深入理解和常见实现方式，希望对你理解单例模式有所帮助。在实际开发中，灵活运用并结合具体场景选择合适的单例模式将有助于提高代码质量和可维护性。
### Java 单例模式详解 #### 一、什么是单例模式？ 单例模式是一种常用的软件设计模式，在这种模式中，一个类只能拥有一个实例，并且该类必须自行创建并提供这个实例。通常，单例模式用于确保某个类在整个应用程序...
总的来说，这个项目为学习和理解单例模式和工厂模式在实际开发中的应用提供了一个很好的示例。通过结合这两种模式，可以构建出既保证了对象唯一性，又能灵活应对不同产品创建需求的系统。对于Java开发者来说，深入...
Java设计模式是面向对象编程中的重要概念，它们是软件开发中经过验证的、解决常见问题的最佳实践。...观看这些视频，可以更深入地理解并掌握Java中的单例模式，从而在实际开发中灵活运用，提升代码质量。
下面我们将深入探讨Java单例模式的实现方式、优缺点以及注意事项。 一、单例模式的实现方式 1. 饿汉式（静态常量） 这是最简单的单例实现，通过静态常量在类加载时就初始化单例，保证了线程安全，但同时也意味着...
本文将详细介绍几种常见的单例模式实现方式，并探讨它们在实际开发中的应用和最佳实践。 在实现单例模式时，应注意以下几点： 确保单例类不被继承，可以通过将构造函数设置为私有来实现。 考虑线程安全问题，选择...
在Java等面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。结合工厂模式，可以进一步优化单例的创建过程，提高代码的可读性和可维护性。 单例模式的核心在于控制类的实例化...
在给定的内容中提到的`Martin`类就是一个典型的单例模式实现案例。它通过将构造器私有化以及提供一个静态成员变量来确保了`Martin`类的唯一实例的存在。 ```java public class Martin { private Martin() { // ...
在Java等面向对象编程语言中，单例模式常用于控制资源的共享，如全局配置、数据库连接池、日志服务等。这种模式可以避免因实例化多次而导致的资源浪费和状态冲突。 **单例模式的基本结构与特性** 1. **私有构造...
在Java编程语言中，单例模式是一种常用的软件设计模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点...在阅读《浅议单例模式之线程安全.doc》文档时，可以深入理解这些细节，以便更好地运用单例模式。
本篇文章将对标题与描述中提到的几个关键Java设计模式进行深入分析。 首先，让我们来看一下MVC模式，这是一种广为接受的架构模式，用于构建用户界面。在MVC模式中，Model层管理数据以及业务逻辑，View层负责将数据...
本篇将深入探讨标题中提及的几种设计模式：Model-View-Controller（MVC）模式、单例模式、代理模式以及工厂模式，尤其是简单工厂模式。 **1. Model-View-Controller (MVC) 模式** MVC模式是一种架构模式，它将应用...
本次我们将深入探讨两种设计模式——单例模式和装饰模式，它们在Java编程中都有着广泛的应用。 首先，让我们来理解“单例模式”。单例模式是一种创建型设计模式，其核心思想是保证一个类只有一个实例，并提供一个...
通过这个小练习，初学者可以了解到单例模式的核心思想和实现方式，同时也可以深入理解Java中的类加载机制、线程同步以及volatile关键字的作用。通过实践这些代码，可以提高对Java内存模型和多线程的理解，进一步提升...
在Java中，常见的单例模式实现方式有： 1. **饿汉式（静态常量）**： 这种方式是在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快，且线程安全。 ```java public class Singleton { private ...
在本文中，我们将深入探讨三种工厂设计模式——简单工厂模式、抽象工厂模式和工厂方法模式，以及两种单例模式——饿汉单例模式和懒汉单例模式。这些模式都是面向对象设计中的重要组成部分，对于理解和构建可维护、可...
在Java中，实现单例模式有多种方法，比如懒汉式、饿汉式和双重检查锁定等。懒汉式是在第一次使用时才创建单例，延迟初始化；饿汉式是在类加载时就创建单例，无论是否需要；而双重检查锁定则结合了两者，既保证了线程...