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关键字实现同步代码块,这样造成了性能损耗;而饿汉模式不能延迟实例化对象,静态内部类单例模式的实现,既保证了线程的安全,有能够延迟加载,也就是在第一次使用的时候加载。

你可能感兴趣的:(05.并发编程之单例和多线程)