多线程之ThreadLocal，单例模式

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wu2374633583/article/details/80880203

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;
    }


}