【Java互联网架构学习----001--09】并发编程之ThreadLocal的概念,单例与多线程

知识点1:

ThreadLocal的概念:线程局部变量,使用空间换时间,解决多线程间并发访问变量的方案,完全不提供锁,为每个线程提供变量的独立副本,保证线程安全

优劣:性能方面不具备绝对的优势,并发不是很高的场景下使用加锁会更好,在高并发或者竞争激烈的场景中,它作为一种无锁的,线程安全的解决方案,可以在一定程度上减少锁竞争

该属性是属于每个Thread实例特有的，所以能提供整个线程使用且不与其他线程共享

知识点2：

什么是单例：所谓单例就是所有的请求都用一个对象来处理，单例模式的对象在整个系统中只有一份，多例模式可以有多个实例。

单例的形式：懒汉式、饿汉式、双重锁的形式;

package com.neo.study001.redio09;

/**
 * @author liyy
 * @date 2020/4/23 22:15
 * @Function 懒汉模式
 */
public class LazySingleton {
    private static LazySingleton lazySingleton;

    public static LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + LazySingleton.getInstance().hashCode());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + LazySingleton.getInstance().hashCode());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

package com.neo.study001.redio09;

/**
 * @author liyy
 * @date 2020/4/23 22:15
 * @Function 饿汉模式
 */
public class HungrySingleton {
    private static HungrySingleton singleton = null;

    static {
        singleton = new HungrySingleton();
    }

    public static HungrySingleton getInstance() {
        return singleton;
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + HungrySingleton.getInstance().hashCode());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + HungrySingleton.getInstance().hashCode());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

package com.neo.study001.redio09;

/**
 * @author liyy
 * @date 2020/4/23 22:15
 * @Function 静态内部类单例模式
 */
public class InnerClassSingleton {
    
    private static class InnerClassHolder {
        private static final InnerClassSingleton singleton = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.singleton;
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + InnerClassSingleton.getInstance().hashCode());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + InnerClassSingleton.getInstance().hashCode());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

package com.neo.study001.redio09;

/**
 * @author liyy
 * @date 2020/4/23 22:15
 * @Function 双重校验锁单例模式
 */
public class DoubleCheckSingleton {

    private volatile static DoubleCheckSingleton singleton;

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

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + DoubleCheckSingleton.getInstance().hashCode());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + "," + DoubleCheckSingleton.getInstance().hashCode());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}