单列模式与多线程

Java单例模式详解

设计模式是一种思想，适合于任何一门面向对象的语言。共有23种设计模式。

单例设计模式所解决的问题就是：保证类的对象在内存中唯一。

举例：

A、B类都想要操作配置文件信息Config.java，所以在方法中都使用了Config con=new Config();但是这是两个不同的对象。对两者的操作互不影响，不符合条件。

解决思路：

1.不允许其他程序使用new创建该类对象。（别人new不可控）
2.在该类中创建一个本类实例。
3.对外提供一个方法让其他程序可以获取该对象。

解决方法：单例模式。

步骤：
1.私有化该类的构造函数
2.通过new在本类中创建一个本类对象。
3.定义一个共有的方法将创建的对象返回

 

单例模式分为饿汉式和懒汉式

• 饿汉式:  不支持并发

/**
 * 饿汉式:   缺点：
 *              此模式只能运行在单线程下，且类在加载时就已经创建好了实例，不管需不需要用。
 *              不适合并发编程，由于无论是否用到类，对象一直被创建，耗费资源
 */
public class Single {

    private static final Single instance = new Single();
    private Single(){};

    public static Single getInstance() {
        return instance;
    }
}

 

• 懒汉式:

/**
 * 懒汉式:  此模式只能运行在单线程下，在调用获取实例的方法时才创建实例。
 *      
 *      多线程的缺点:  如果有两个线程对该对象进行并发操作，当A线程要创建实例时，B线程早就创建完实例
 *      导致创建了多个实例的创建，从而违背了单例模式
 */
public class Single2 {

    private static Single2 instance = null;
    private Single2(){}
    public static Single2 getInstance() {
        if (instance == null)
            instance = new Single2();

        return instance;
    }
}

 

• 懒汉式、支持并发、synchronized：

/**
 * 懒汉式、支持多并发、效率低
 *       支持多线程并发，虽然避免了单例模式的风险，但是每个进程都会在使用对象时使用方法
 *   并且进行申请锁(无论对象是否创建，每个线程都会申请判断)，导致资源的浪费，以及时间，
 *   毕竟锁资源开销比较大
 *   
 *       synchronized 锁住了整个方法，当有多个线程需要访问方法时，不管实例有没有创建，
 *       都会要排队等待才能拿到实例，效率低。需要改进：只有第一次创建实例时才需要锁，其他时候不需要加锁。
 */
public class Single3 {

    private static Single3 instance = null;

    private Single3(){}

    public synchronized static Single3 getInstance() {
        if (instance == null){
            instance = new Single3();
        }
        return instance;
    }
}

 

• 双重检查锁

/**
 * volatile 关键字保证了内存可见性，所有线程都会去主存中取数据而不是在线程的缓存中取，保证了数据的更新能实时地对任何线程可见。
 * 假如有两个线程同时到达了1，它们都去创建实例，这时候如果没有第二次判断，就会多次创建实例了。二次判断保证了多线程下只创建一个实例。
 */
public class Single4 {

    private volatile static Single4 instance = null;

    private Single4(){}

    public static Single4 getInstance() {
        if (instance == null){
            synchronized (Single4.class) {
                if (instance == null)
                    instance = new Single4();

            }
        }
        return instance;
    }
}


volatile作为java中的关键词之一，用以声明变量的值可能随时会别的线程修改，使用volatile修饰的变量会强制将修改的值立即写入主存，主存中值的更新会使缓存中的值失效(非volatile变量不具备这样的特性，非volatile变量的值会被缓存，线程A更新了这个值，线程B读取这个变量的值时可能读到的并不是是线程A更新后的值)。volatile会禁止指令重排。

2.volatile特性

volatile具有可见性、有序性，不具备原子性。

注意，volatile不具备原子性，这是volatile与java中的synchronized、java.util.concurrent.locks.Lock最大的功能差异，这一点在面试中也是非常容易问到的点。

• 静态私有内部类(常用)

/**
 * 内部类的好处：内部类在被调用的时候才实例化其静态成员变量，高！
 */
public class Single5 {

    private Single5(){}

    private static class SingletonHolder{
        private static Single5 instance = new Single5();
    }

    public static Single5 getInstance(){
        return SingletonHolder.instance;
    }
}