这次主要写了四种类型的单例模式
- 饿汉式
- 懒汉式
- 同步方法锁
- 双重锁定
自己留着以后忘记时查看用的，所以注释比代码都多。项目结构很简单，一个Singleton类，一个测试类。直接上代码了。
package com.dyk.singleton;
public class Singleton {
private static Singleton mSingleton;
/**
* <b>饿汉式单例</b>
* <p>
* 静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称为饿汉式单例类
*/
private static Singleton mSingleton2 = new Singleton();
/** <b>饿汉式单例</b> */
public static Singleton getInstance5() {
return mSingleton2;
}
/** 私有化构造方法，防止从外界直接创建对象。 */
private Singleton() {
}
/**
* <b>懒汉式单例。</b>在多线程模型下可能产生多个实例。 例如：当两个线程同时运行到new Singleton()那一行，则会产生两个对象。
* @return instanceof Singleton
*/
public static Singleton getInstance() {
if (mSingleton == null) {
mSingleton = new Singleton();
}
return mSingleton;
}
/**
* 运用同步锁机制，锁住获取实例的方法。 优点：可以保证一个类中只有一个实例。
* 缺点：在多线程环境下，第一个线程进入getInstance2()方法后，其余线程都必须等待，直到第一个线程释放资源
* 假设有100个线程，那么第一百个线程需要等待前99个线程全部释放资源后才能进入getInstance2()方法
*
* @return instanceof Singleton
*/
public static synchronized Singleton getInstance2() {
if (mSingleton == null) {
mSingleton = new Singleton();
}
return mSingleton;
}
/**
* 和getInstance2()很类似。
* 区别是getInstance2()锁住的是方法，在线程访问getInstance2()的同时，其他线程可以访问Singleton类的其他方法。
* 而getInstance3()锁住的是整个类，独占了整个类的访问。
* @return instanceof Singleton
*/
public static Singleton getInstance3() {
synchronized (Singleton.class) {
if (mSingleton == null) {
mSingleton = new Singleton();
}
}
return mSingleton;
}
/**
* <b>双重锁定(Double-Check-Locking)</b><br/>
* 在synchronized关键字内还要再进行一次判空是因为：<br/>
* 如果同时有两个线程调用GetInstace4()方法时，<br/>
* 它们都将可以通过第一重mSingleton==null的判断。<br/>
* 然后由于synchronized机制，这两个线程只有一个可以进入。然后由第一个进入的线程创建相应的实例。<br/>
* 如果没有第二重判断，则会创建出两个实例，这明显与单例精神不符。
* @return instanceof Singleton
*/
public static Singleton getInstance4() {
if (mSingleton == null) {
synchronized (Singleton.class) {
if (mSingleton == null) {
mSingleton = new Singleton();
}
}
}
return mSingleton;
}
}
package com.dyk.singleton;
public class SingletonTest {
public static void main(String[] args) {
// hungerManTest();
// lazyManTest();
// synchronizedTest();
// doubleCheckLockingTest();
}
private static void doubleCheckLockingTest() {
for (int i = 0; i < 1000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
Singleton mSingleton = Singleton.getInstance4();
System.out.println("Thread name="
+ Thread.currentThread().getName() + "实例内存地址="
+ mSingleton.toString());
}
}).start();
}
}
private static void synchronizedTest() {
for (int i = 0; i < 1000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
Singleton mSingleton = Singleton.getInstance2();
System.out.println("Thread name="
+ Thread.currentThread().getName() + "实例内存地址="
+ mSingleton.toString());
}
}).start();
}
}
/** 懒汉式单例测试 */
private static void lazyManTest() {
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
// 一次测试不一定成功，需要多运行几次
Singleton mSingleton = Singleton.getInstance();
System.out.println("Thread name="
+ Thread.currentThread().getName() + "实例内存地址="
+ mSingleton.toString());
}
}).start();
}
}
/** 饿汉式单例测试 */
private static void hungerManTest() {
for (int i = 0; i < 1000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
Singleton mSingleton = Singleton.getInstance5();
System.out.println("Thread name="
+ Thread.currentThread().getName() + "实例内存地址="
+ mSingleton.toString());
}
}).start();
}
}
}
