Java并发编程---ThreadLocal和单例模型

r囧r小猫 2022-06-02 02:26 78阅读 0赞

**一.ThreadLocal**

**1.概念**

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

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

**2.代码示例**

package com.thread.local;
    
    public class ConnThreadLocal {
        /**
         * ThreadLocal只针对一个线程有效,在一个线程内有效,未必也对另一个线程有效
         */
    	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) {
    		final ConnThreadLocal ct = new ConnThreadLocal();
    		Thread t1 = new Thread(new Runnable() {	
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				ct.setTh("张三");
    				ct.getTh();
    			}
    		},"t1");
    		
    		Thread t2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					Thread.sleep(1000);
    					ct.getTh();
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		},"t2");
    		
    		t1.start();
    		t2.start();
    	}
    
    }

**二.单例&多线程**

**2.1 概念**

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

**double check instance**

**static inner class**

**2.2 代码示例**

package com.thread.local;
    
    public class DubbleSingletop {
    
    	private static DubbleSingletop ds;
    	
    	public static DubbleSingletop getDs(){
    		if(ds == null){
    			try {
    				//模拟初始化对象的准备时间
    				Thread.sleep(3000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			synchronized (DubbleSingletop.class) {
    				if(ds == null){
    					ds = new DubbleSingletop();
    				}
    			}
    		}
    		return ds;
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            Thread t1 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				System.out.println(DubbleSingletop.getDs().hashCode());
    			}
    		},"t1");
            
            Thread t2 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				System.out.println(DubbleSingletop.getDs().hashCode());
    			}
    		},"t2");
            
            Thread t3 = new Thread(new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				System.out.println(DubbleSingletop.getDs().hashCode());
    			}
    		},"t3");
            
            t1.start();
            t2.start();
            t3.start();
    	}
    
    }

package com.thread.local;
    
    /**
     * 单例模式:跟类一起初始化,天然的就是线程安全
     * @author lhy
     * @time   2017.12.26
     */
    public class Singletion {
    
    	private static class InnerSingletion{
    		private static Singletion single = new Singletion();
    	}
    	
    	public static Singletion getInstance(){
    		return InnerSingletion.single;
    	}
    }