003设计模式 -- 单例模式

第一种:

　　饿汉式

public class EagerLoadBalancer {
  private final static EagerLoadBalancer INSTANCE = new EagerLoadBalancer();

  private EagerLoadBalancer() {
  }

  public static EagerLoadBalancer getInstance() {
    return INSTANCE;
  }

  public static void main(String[] args) {
    EagerLoadBalancer eagerLoadBalancer1 = EagerLoadBalancer.getInstance();
    EagerLoadBalancer eagerLoadBalancer2 = EagerLoadBalancer.getInstance();
    System.out.println("hashCode："+eagerLoadBalancer1.hashCode());
    System.out.println("hashCode："+eagerLoadBalancer2.hashCode());
  }
}

　　分析

　　　　利用class Load机制, 在加载时进行实例化, 同时静态方法只在编译期间执行一次初始化, 所以也就只有一个对象, 使用的时候已经被初始化完毕, 可以直接调用

　　　　优点: 相比懒汉式, 编译期就已经初始化, 使用的时候速度最快

　　　　缺点: 不使用也会被初始化出来, 消耗内存

第二种:
　　懒汉式1

public class LazyLoadBalancer1 {
  private static LazyLoadBalancer1 loadBalancer;
  private LazyLoadBalancer1() {
  }

  public static LazyLoadBalancer1 getInstance() {
    // 第一步：假设T1,T2两个线程同时进来且满足 loadBalancer == null
    if (loadBalancer == null) {
      // 第二步：那么 loadBalancer 即会被实例化2次
      loadBalancer = new LazyLoadBalancer1();
    }
    return loadBalancer;
  }

  public static void main(String[] args) {
    LazyLoadBalancer1 balancer1 = LazyLoadBalancer1.getInstance();
    LazyLoadBalancer1 balancer2 = LazyLoadBalancer1.getInstance();
    System.out.println("hashCode："+balancer1.hashCode());
    System.out.println("hashCode："+balancer2.hashCode());
  }
}

　　分析

　　　　在单线程环境一切正常, balancer1和balancer2两个对象的hashCode一模一样. 由此可以判断出堆栈中只有一份内容, 不过该代码块中存在线程安全隐患. 因为缺乏竞争条件, 多线程环境资源竞争的时候就显得不太乐观了

对上面代码进行改造

public class LazyLoadBalancer2 {
  private static LazyLoadBalancer2 loadBalancer;
  private LazyLoadBalancer2() {
  }

  public synchronized static LazyLoadBalancer2 getInstance() {
    // 第一步：假设T1,T2两个线程同时进来且满足 loadBalancer == null
    if (loadBalancer == null) {
      // 第二步：那么 loadBalancer 即会被实例化2次
      loadBalancer = new LazyLoadBalancer2();
    }
    return loadBalancer;
  }

  public static void main(String[] args) {
    LazyLoadBalancer2 balancer1 = LazyLoadBalancer2.getInstance();
    LazyLoadBalancer2 balancer2 = LazyLoadBalancer2.getInstance();
    System.out.println("hashCode："+balancer1.hashCode());
    System.out.println("hashCode："+balancer2.hashCode());
  }
}

　　分析

　　　　毫无疑问，知道synchronized关键字的都知道, 同步方法在锁没释放之前，其它线程都在排队候着呢, 想不安全都不行啊，但在安全的同时，性能方面就显得短板了, 只初始化一次, 但是每次上来都要加个锁, 降低性能

　　懒汉式2

public class LazyLoadBalancer4 {
  private static LazyLoadBalancer4 loadBalancer;

  private LazyLoadBalancer4() {
  }

  private static class LoadBalancerHolder {
    private final static LazyLoadBalancer4 INSTANCE = new LazyLoadBalancer4();
  }


  public static LazyLoadBalancer4 getInstance() {
    return LoadBalancerHolder.INSTANCE;
  }

  public static void main(String[] args) {
    LazyLoadBalancer4 balancer1 = LazyLoadBalancer4.getInstance();
    LazyLoadBalancer4 balancer2 = LazyLoadBalancer4.getInstance();
    System.out.println("hashCode："+balancer1.hashCode());
    System.out.println("hashCode："+balancer2.hashCode());
  }
}

　　分析

　　　　我们在LazyLoadBalancer里增加一个静态(static)内部类, 在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用. 由于静态单例对象没有作为LazyLoadBalancer的成员变量直接实例化, 类加载时并不会实例化LoadBalancerHolder，因此既可以实现延迟加载，又可以保证线程安全，不影响系统性能