java设计模式---单例模式

概念:保证一个类仅有一个实例，并提供一个访问它的全局访问点。

示例一:

package com.accp.sigleton;
///
//  饿汉单例模式
// 线程安全,调用时的反应速度快,在类加载的时候就创建好静态对象
//  缺点:资源利用率不高,可能该实例并不需要,但却被系统加载
//
//
public class Single{

 public Single(){
  System.out.println("Ok");
 }
 private>  
 @SuppressWarnings("unused")
 private static Single getInstance(){
  return instance;
 }
 

}

示例二:

package com.accp.sigleton;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

///
// 不同方法的单例设计
// @author Administrator
//
//
public class LazySigleton {

 public LazySigleton() {};

 private static LazySigleton instance;
 
 private>

 private static Lock lock = new ReentrantLock();
// 
//   懒汉单例模式 延迟加载法在适用于单线程环境，它不是线程安全的， 引入多线程时，就必须通过同步来保护getInstance（）方法，
//  否则可能会返回LazySingleton的两个不同实例。 比如，一个线程在判断instance为null后，还没来得及创建新的instance，
//   另一个线程此时也判断到instance为null，这样两个线程便会创建两个LazySingleton实例。
//  优点:资源利用率高,不执行getInstance就不会被实例。 缺陷：第一次加载时反应不快，多线程使用不必要的同步开销大
//  每次调用getInstance（）方法时，都要同步，而且很多时候的同步是没必要的，
//  这将会极大地拖垮性能（尤其在需要多次调用getInstance方法的地方）。
// 
//  @author>    instance = new LazySigleton();

  return instance;
 }

// 
//   显式加锁
// 
//  @return
// 
 public static synchronized LazySigleton getInstanceA() {

  try {
   lock.lock();
   if (instance ==>    }
   return instance;
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   lock.unlock();
  }
  return instance;

 }

// 
// >    instance = new LazySigleton();

  return instance;
 }

// 
// >    synchronized (LazySigleton.class) {
    if (instance ==>     }
    return instance;
   }
  }
  return instance;

  
 }
// 
// >    synchronized (obj) {
    if (instance ==>     }
    return instance;
   }
   
  }
  return instance;

  
 }
}
测试:比较两个对象的哈希码是否一致

package com.accp.sigleton;

public class SingTest {

 public static void main(String[] args) {
  
  LazySigleton>   LazySigleton s2 = new LazySigleton();
  
  System.out.println(s1.getInstanceA().hashCode());
  System.out.println(s2.getInstanceA().hashCode());
 }
}