05.并发编程之单例和多线程

1、ThreadLocal

线程局部变量，是一种多线程间并发访问变量的解决方案，与synchronized加锁方式不同，ThreadLocal完全不提供锁，而使用以空间换时间的手段，为每个线程提供变量的独立副本，保障线程安全。
从性能上讲， ThreadLocal不具有绝对的优势，在并发不是很高的时候，加锁性能会更好，但在高并发或者竞争激烈时，如硬件较好，用ThreadLocal一定程度上减少锁竞争。

2、单例模式

单例模式的饥饿与懒汉模式在多线程中是不行的，性能不高且不能保证线程安全
静态内部类模式，推荐，最安全，最可靠

    public class InnerSingleton {
        private static class Singleton {
            private static Singleton single = new Singleton();
        }
        public static Singleton getInstance() {
            return Singleton.single;
        }
    }

    比较：
    package demo2;

    public class MySingleTon {

        // 1:饿汉 一旦完成加载，就把单例初始化完成，getInstance时已存在

        private final static MySingleTon singleTon = new MySingleTon();

        private MySingleTon() {
            System.out.println("starting init single");
        }

        public static MySingleTon getInstance() {
            return singleTon;
        }

        public static void main(String[] args) {
            System.out.println("-------------");
            MySingleTon sinle1 = MySingleTon.getInstance();
            System.out.println("-------------");
            MySingleTon sinle2 = MySingleTon.getInstance();
            System.out.println("-------------");
            MySingleTon sinle3 = MySingleTon.getInstance();
        }
    }

    打印：
    starting init single
    -------------
    -------------
    -------------

    
    package demo2;

    public class MySingleTon {

        // 2 线程安全的 懒汉式 调用getInstance时 初始化实例

        private static MySingleTon single = null;

        private MySingleTon() {
            System.out.println("starting init single");
        }

        public static MySingleTon getInstance() {
            if (single == null) {
                synchronized(MySingleTon.class) {
                    if (single == null) {
                        single = new MySingleTon();
                    }
                }
            }
            return single;
        }

        public static void main(String[] args) {
            System.out.println("-------------");
            MySingleTon sinle1 = MySingleTon.getInstance();
            System.out.println("-------------");
            MySingleTon sinle2 = MySingleTon.getInstance();
            System.out.println("-------------");
            MySingleTon sinle3 = MySingleTon.getInstance();
        }
    }

    打印
    -------------
    starting init single
    -------------
    -------------

    public class Singleton  
    {  
        private Singleton(){ }  
        
        public static Singleton getInstance()  
        {  
            return Nested.instance;       
        }  
        
        //在第一次被引用时被加载  
        static class Nested  
        {  
            private static Singleton instance = new Singleton();  
        }  
        
        public static void main(String args[])  
        {  
            Singleton instance = Singleton.getInstance();  
            Singleton instance2 = Singleton.getInstance();  
            System.out.println(instance == instance2);  
        }  
    }  

3、至于1、2、3这三种实现又有些区别:

• 第1种：饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，
• 第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
• 第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

PS1

一种通过内部类来实现单例的方式，静态内部类只能访问外部类的静态方法和静态属性。现在一般利用这个特性来实现单例模式。因为类在初始化的时候线程是互斥的，可以完美的解决单例创建冲突的问题。

PS2

单例模式是一种常见的模式，懒汉模式考虑线程安全需要在获取单例的方法添加synchronized关键字实现同步代码块，这样造成了性能损耗；而饿汉模式不能延迟实例化对象，静态内部类单例模式的实现，既保证了线程的安全，有能够延迟加载，也就是在第一次使用的时候加载。