多线程之ThreadLocal，单例模式

た入场券 2022-05-21 06:24 163阅读 0赞

## 1 ThreadLocal ##

**概念：线程局部变量，是一种多线程间并发访问变量的一种解决方案，与其synchronized加锁的方式不同，它完全不提供锁，而使用以空间换时间的手段，为每个线程提供变量的独立副本，以保障线程安全。**

从性能上说，ThreadLocal不具有绝对优势，在并发不是很高的情况下，加锁的性能会更好，但是作为一套与锁完全无关的线程安全解决方案，在高并发或者竞争激烈的场景下，使用ThreadLocal可以在一定程度上减少锁竞争问题。

package com.wuk.Demo;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    /** * ThreadLocal的使用 * @author Administrator * */
    public class MyThread006 { 
    
        private 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) {
    
            final MyThread006 mt006=new MyThread006();
            Thread t1=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    mt006.setTh("wuk");
                    mt006.getTh();
                }
            },"t1");
    
            Thread t2=new Thread(new Runnable() {
    
                @Override
                public void run() {
                    // TODO Auto-generated method stub
    
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    mt006.getTh();
    
                }
            },"t2");
    
            t1.start();
            t2.start();
        }
    
    }

结果：

t1:wuk
    t2:null

**结果说明尽管使用的是全局的变量，但是线程之间值是不会相互影响的，也就是线程安全。**

## 2 单例模式 ##

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

**dubble check instance**  
**static inner class**(静态内部类，更常用)

dubble check instance 单例模式

package com.wuk.thread;
    /** * dubble check instance 单例模式 * @author Administrator * */
    public class MyThread01 { 
    
        private static MyThread01 mt;
        public static MyThread01 getMt(){
    
            if(mt==null){
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (MyThread01.class) {
                    if(mt==null){
                        mt=new MyThread01();
                    }
                }
            }
    
            return mt;
        }
    
        public static void main(String[] args) {
    
            Thread t1=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    System.out.println(MyThread01.getMt().hashCode());
    
                }
            },"t1");
    
            Thread t2=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    System.out.println(MyThread01.getMt().hashCode());
                }
            },"t2");
    
            t1.start();
            t2.start();
        }
    }

结果：

1947425526
    1947425526

static inner class(静态内部类，更常用)

package com.wuk.thread;
    /** * static inner class 单例模式 静态内部类 * @author Administrator * */
    public class MyThread02 { 
    
        public static class InnerSingletion{ 
    
            private static MyThread02 mt=new MyThread02();
    
        }
    
        public  static MyThread02 getInstance(){
    
            return InnerSingletion.mt;
        }
    
    
    }