java单例 同步 多线程

Java单例设计模式，多线程下同步

设计模式 多线程 java class thread string

单例模式的特点：

1. 只创建一次
2. 私有的属性
3. 公有的访问方法

单例模式的分类：

1. 懒汉（LazySingleton）；默认不自动实例化，等到用的时候根据当前情况实例化，并且返回当前对象；
2. 恶汉（EagerSingleton）；在类第一次加载的时候强制实例化；
   

用处：

         一般用在配置文件的读取，有些东西只需要加载一次，以后重复使用。

示例代码：

package myThread;

/**
 * 单例模式，懒汉模式
 *
 * @author Champion.Wong
 *
 */
public class LazySingleton {

    private static LazySingleton singleton = null;

    /**
     * 私有的构造方法，防止被多次实例化
     *
     */
    private LazySingleton() {
    }

    /**
     * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回
     *
     * @return LazySingleton
     */
    public static LazySingleton getInstance() {
        if (null == singleton)
            singleton = new LazySingleton();
        return singleton;
    }
}

package myThread;

/**
 * 单例模式，饿汉模式
 * @author Champion.Wong
 *
 */
public class EagerSingleton {

    private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象

    /**
     * 私有的构造方法，防止被多次实例化
     *
     */
    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return singleton;
    }
}

前边说过了，单例只创建一次，来做个测试，在单例的类中加入一个属性，当这个类在实例化的时候，会将当前的时间赋给这个属性。我们创建两个单例类的对象，然后分别拿出它们类中的这个属性进行对比。

所以，在EagerSingleton中加入属性：createdTime

package myThread;

/**
 * 单例模式，饿汉模式
 * @author Champion.Wong
 *
 */
public class EagerSingleton {

    private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象

    /**
     * 私有的构造方法，防止被多次实例化
     *
     */
    private EagerSingleton() {
        createdTime = System.currentTimeMillis();
    }

    public static EagerSingleton getInstance() {
        return singleton;
    }

    private long createdTime = 0L; //此类的创建时间，在类实例化的时候赋值
    public long getCreatedTime() {
        return createdTime;
    }
}

然后，写个Test：

package myThread;

public class Test_Singleton {

    public static void main(String[] args) {
        EagerSingleton singleton1 = EagerSingleton.getInstance();
        try {
            Thread.sleep(2000); //让当前线程睡眠2000ms，这样，两个对象实例化的时间就差2s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        EagerSingleton singleton2 = EagerSingleton.getInstance();

        System.out.println("Singleton1:" + singleton1.getCreatedTime());
        System.out.println("Singleton2:" + singleton2.getCreatedTime());
    }

}

最后控制台输出的内容为：

两个对象的实例化的时间相同，证明单例设想成功！

当多个线程访问单例类的时候，必须要保证同时只能由一个线程访问，当这个线程访问结束了，其它线程才能访问。这是就要给单例的访问方法加个同步锁（synchronized）。

修改后的LazySingleton为：

package myThread;

/**
 * 单例模式，懒汉模式
 *
 * @author Champion.Wong
 *
 */
public class LazySingleton {

    private static LazySingleton singleton = null;

    /**
     * 私有的构造方法，防止被多次实例化
     *
     */
    private LazySingleton() {
    }

    /**
     * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回
     *
     * @return LazySingleton
     */
    synchronized public static LazySingleton getInstance() {
        if (null == singleton)
            singleton = new LazySingleton();
            System.out.println(Thread.currentThread().getName() + System.currentTimeMillis());
        try {
            Thread.sleep(900); //假设每个线程访问的时候都需要耗费一定的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return singleton;
    }
}

做个测试，起两个线程，没个线程中分别调用单例类的访问方法，每次访问的时候输出访问的时间，判断时间是否相等。如果相等，同步失败，如果不等，同步成功！

package myThread;

public class Test_Thread_Singleton {

    /**
     * @param args
     */
    public static void main(String[] args) {
        SingletonThread st = new SingletonThread();
        SingletonThread st1 = new SingletonThread();
        st.start();
        st1.start();
    }

}

class SingletonThread extends Thread {
    private LazySingleton singleton = null;
    public void run() {
        while (!this.isInterrupted()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = LazySingleton.getInstance();
        }
    }
}

看控制台的输出内容：

时间差不多都不一致，同步成功！限制了同时访问