设计模式--单例模式

1. 两种单例设计模式的区别

单例设计主要有两种方式，一般称之为饿汉式和懒汉式，接下来就对它们做些介绍，先放代码：

• 饿汉式

  class HungrySingle {
  private static final HungrySingle s = new HungrySingle();
  private HungrySingle() {
  }
  public static HungrySingle getInstance() {
    return s;
  }
  }

• 懒汉式

  class LazySingle {
  private static LazySingle s = null;
  private LazySingle() {
  }
  public static LazySingle getInstance() {
      if (s == null) {
          synchronized (LazySingle.class) {
              if (s == null) {
                  s = new LazySingle();
              }
          }
      }
   return s;
  }
  }

• 比较:

  饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变。懒汉式是在程序在被访问时才进行对象的创建，如果在创建实例对象时不加synchronized进行同步处理，则会导致对对象的访问不是线程安全的。饿汉式在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。在开发中是推荐使用饿汉式的，当然如果单例模式在系统中使用频率很低或者几乎不会用到，那么懒汉式就是一个不错的选择。

• 深度分析 —— 单例设计模式的用途：

单例设计模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛。比如，对有可能存在大量并发操作的，需要数据库连接的系统来说，如果我们对每次指令操作都创建一个数据库连接，那么系统的大部分消耗将会放在维护连接上而非直接查询操作上，很有可能会导致系统崩溃，这显然是不可取的。 如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，那么我们将会节省很多内存开销并提高cpu的利用率。这就是单例设计模式的用途。当然单例设计模式并不是只适用于这样的情况，
我们对单例用户模式的适用性可以有如下理解：

1. 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
2. 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

关于Instance类的设计，我们应该保证单例设计模式类是我们取得单例设计实例的唯一访问点。那么我们应该保证在程序中尽量避免允许创建Instance实例。 通过将构造函数声明为private可以防止程序员通过new关键字调用构造函数创建对象。并且在Instance类中创建getXXX()方法调用构造函数并返回具体Instance实例。具体代码如下：

class Instance{
private Instance(){}
public static Instance getSelf(){  return new Instance();  }
}
//饿汉式
class HungrySingle{
private static Instance _instance = Instance.getSelf();
private HungrySingle(){}
public static Instance getInstance(){  return _instance;  }
}
//懒汉式
class LazySingle{
private static  Instance it = null;
private LazySingle(){}
public static Instance getInstance(){
if(it==null){
synchronized(LazySingle.class){  it = Instance.getSelf();  }
                  }
return it;
            }
}

2. 多线程安全问题

当了解完了单例设计模式之后，我们来谈谈多线程的问题。
首先，多线程的高效和并发是我们众所周知的，除此之外，那么我们最关心的问题就是安全问题了。多线程出现安全问题的原因在于：
当多条语句在操作同一个线程的共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据出错。
解决方法：对多条操作共享数据的语句，在一个线程完全执行完之前，其他线程不参与执行过程，也就是加锁或者叫同步。

• 简单的说就是同步形式一般有两种：
  • 同步代码块；

    synchronized(Object){
    需要同步的内容（一般是涉及到共享数据的执行操作）；
    }

  • 同步函数(从形式上来说同步函数相对更简单些，少了一层缩进)；

     public synchronized void fuction(){}

同步函数需要被对象调用。那么函数都有一个所属对象引用，就是this。所以同步函数用的锁是this。当同步函数被静态修饰后，使用的的锁不是this，因为静态方法中不能定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类型.class 该对象的类型是Class；静态的同步方法，使用的锁是该方法所在类的字节码文件对象 类名.class

• 同步的前提：

  1. 必须是两个或两个以上的线程；
  2. 必须是多个线程使用同一个锁；

必须得保证同步中只有一个线程在运行。

• 同步的优缺点：

  1. 优点： 解决了多线程的安全问题。
  2. 缺点：多个线程需要判断锁，较为消耗资源。

• 当问题出现时如何寻找问题：

  1. 明确哪些代码是多线程运行代码；
  2. 明确共享数据；
  3. 明确多线程运行代码中那些语句是操作共享数据的。

原文：http://www.jianshu.com/p/0f9ad56f477e