并发编程(8)-单例和多线程

墨蓝 2022-06-06 09:22 125阅读 0赞

# 1.ThreadLocal #

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

package com.thread.mythread.conn010;
    
    public class ConnThreadLocal {
        public static ThreadLocal<String> th = new ThreadLocal<String>();
        public void setTh(String value){
            th.set(value);
        }
        public void getTh(){
            System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
        }
        public static void main(String[] args) throws InterruptedException {
            final ConnThreadLocal ct = new ConnThreadLocal();
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    ct.setTh("张三");
                    ct.getTh();
                }
            }, "t1");
    
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(1000);
                        ct.setTh("李四");
                        ct.getTh();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "t2");
            t1.start();
            t2.start();
        }
    }

运行结果：

> t2:李四  
> t1:张三  
> 或者  
> t1:张三  
> t2:李四

# 2.单例模式 #

最常见的就是饥饿模式和懒汉模式，一个直接实例化对象，一个在调用方法时候进行实例化对象。在多线程模式中，考虑到性能和线程安全问题，我们一般选择下面两种比较经典的单例模式，在性能提高的同时，又保证了线程安全。  
**dubble check instance**

public class DubbleSingleton {
    
        private static DubbleSingleton ds;
    
        public static DubbleSingleton getDs(){
            if(ds == null){
                try {
                    //模拟初始化对象的准备时间...
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (DubbleSingleton.class) {
                    //这里为什么要加双重判断呢？？？？
                    if(ds == null){
                        ds = new DubbleSingleton();
                    }
                }
            }
            return ds;
        }
    
        public static void main(String[] args) {
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(DubbleSingleton.getDs().hashCode());
                }
            },"t1");
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(DubbleSingleton.getDs().hashCode());
                }
            },"t2");
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(DubbleSingleton.getDs().hashCode());
                }
            },"t3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

打印结果：

> 2135403881  
> 2135403881  
> 2135403881  
> 如果不加第二次判断，hashCode是不一样的。

**static inner class**静态内部类（在多线程中经常会使用）

package com.thread.mythread.conn011;
    
    public class InnerSingleton {
    
        private static class Singletion {
            private static Singletion single = new Singletion();
        }
    
        public static Singletion getInstance(){
            return Singletion.single;
        }
    
    
        public static void main(String[] args) {
    
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(InnerSingleton.getInstance().hashCode());
                }
            },"t1");
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(InnerSingleton.getInstance().hashCode());
                }
            },"t2");
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    System.out.println(InnerSingleton.getInstance().hashCode());
                }
            },"t3");
    
            t1.start();
            t2.start();
            t3.start();
    
        }
    }

打印结果：

> 2135403881  
> 2135403881  
> 2135403881