判断是否存在

/**

* 懒汉式

*/

public class LazySingleInstance {

// 私有构造方法

private LazySingleInstance(){};

// 私有的类对象

private static LazySingleInstance instance = null;

// 缺点：

// 1 每次都需要去判断instance 是否为空

// 2 调用时才去new对象，响应比较慢

// 3 多线程时，线程不安全，多线程同时获取该对象，线程不安全，可能会产生多个对象出来

public static LazySingleInstance getInstance() throws InterruptedException {

// 每次都需要判断instance是否为空，浪费资源

if (null == instance) {

Thread.sleep(1000);

instance = new LazySingleInstance();

}

return instance;

}

}

考虑线程

/**

* 懒汉式线程安全方法一

*/

public class ThreadSafeSingleInstance {

// 私有的静态实例

private static ThreadSafeSingleInstance instance;

// 私有的构造方法

private ThreadSafeSingleInstance(){};

/**

* 懒汉式线程安全方法

* 同步锁保护

* 缺点：

* 性能低下，且同时每次均需检查实例是否存在

* @return

* @throws InterruptedException

*/

public synchronized static ThreadSafeSingleInstance getInstance() throws InterruptedException {

if (instance == null) {

Thread.sleep(1000);

instance = new ThreadSafeSingleInstance();

}

return instance;

}

}

/**

* 懒汉式线程安全方法二

*/

public class ThreadSafeSingleInstance {

// 私有的静态实例

private static ThreadSafeSingleInstance instance;

// 私有的构造方法

private ThreadSafeSingleInstance(){};

/**

* 同步块保护加二次判断

* 解决问题

*/

public static ThreadSafeSingleInstance getInstance() throws InterruptedException {

if (instance == null) {

// 进方法后进行实例判断，若实例为空，进入同步块

// 多线程时，多个线程会同时进入到同步块外面等待

// 此时，一个线程拿到ThreadSafeSingleInstance.class 后，其他线程在synchronized块外面等待

// 待锁释放时，一个等待的线程拿到锁，同时再次检查实例是否为空

// 并决定是否要创建实例

synchronized (String.class) {//ThreadSafeSingleInstance.class) {

Thread.sleep(1000);

if (instance == null) {

instance = new ThreadSafeSingleInstance();

}

}

}

return instance;

}

}

每次都去new

/**

* 饿汉式

*/

public class HungrySingleInstance {

// 私有的构造方法

private HungrySingleInstance(){};

// 静态类变量,初始化类时变创建对象

private static HungrySingleInstance instance = new HungrySingleInstance();

// 或采用静态块形式初始化instance

static {

instance = new HungrySingleInstance();

}

/**

* 获取实例方法

* 优点：

* 线程安全，且不存在懒汉式的二次判断问题

* 缺点：

* 初始化即new 实例对象出来，违背资源利用习惯(即不管用不用都初始化实例出来)

* @return

*/

public static HungrySingleInstance getInstance() {

return instance;

}

}

测试类

public class SingleInstanceTest implements Runnable{

HungrySingleInstance hungrySingleInstance = null;

LazySingleInstance lazySingleInstance = null;

ThreadSafeSingleInstance threadSafeSingleInstance = null;

// @Override

// public void run() {

// hungrySingleInstance = HungrySingleInstance.getInstance();

// System.out.println("hungrySingleInstance.hashCode() " + hungrySingleInstance.hashCode());

//

// }

// @Override

// public void run() {

// try {

// lazySingleInstance = LazySingleInstance.getInstance();

// } catch (InterruptedException e) {

// e.printStackTrace();

// }

// System.out.println("lazySingleInstance.hashCode() " + lazySingleInstance.hashCode());

// }

@Override

public void run() {

try {

threadSafeSingleInstance = ThreadSafeSingleInstance.getInstance();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("threadSafeSingleInstance() " + threadSafeSingleInstance.hashCode());

}

public static void main(String args[]) throws InterruptedException{

SingleInstanceTest singleInstanceTest = new SingleInstanceTest();

for (int i=0; i< 100; i++) {

Thread t = new Thread(singleInstanceTest, String.valueOf(i));

t.start();

}

}

}