并发编程基础二

本文介绍了多线程访问共享变量时的并发问题,引出ThreadLocal。它能为每个线程提供本地变量副本,避免线程安全问题,还阐述了其使用示例、实现原理。同时指出ThreadLocal不支持继承性,而InheritableThreadLocal可让子线程访问父线程的本地变量,说明了其原理和应用场景。

多钱程访问同一个共享变量时特别容易出现并发问题,特别是在多个线程需要对个共享变量进行写入时为了保证线程安全,一般使用者在访问共享变量时需要进行适当的同步,如下图所示。

同步的措施一般是加锁,这就需要使用者对锁有一定的了解,这显然加重了使用者的负担。那么有没有一种方式可以做到,当创建一个变量后,每个线程对其进行访问的时候访问的是自己线程的变量呢?其实ThreadLocal就可以做这件事情,虽然ThreadLocal并不是为了解决这个问题而出现的。

ThreadLocal是JDK包提供的,它提供了线程本地变量,也就是如果你创建了一个ThreadLocal变量,那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时,实际操作的是自己本地内存里面变量,从而避免了线程安全问题。创建个ThreadLocal变量后,每个线程都会复制一个变量到自己的本地内存,如下图所示:

1.1 ThreadLocal使用示例

本节介绍如何使用ThreadLocal。本例开启了两个线程,在每个线程内部都设置了本地变量的值,然后调用print函数打印当前本地变量的值。如果打印后调用了本地变量的remove方法,则会删除本地内存中的该变量,代码如下。

public class ThreadLocalTest {

	
	//1.print函数
	static void print(String str) {
		//1.1打印当前线程中本地内存中localVariable变量的值
		System.out.println(str+localVariable.get());
		//1.2清除当前线程中本地内存中的localVariable变量
		//localVariable.remove();
	}
	
	//2.创建ThreadLocal变量
	static ThreadLocal<String> localVariable = new ThreadLocal<>();
	
	
	
	public static void main(String [] args) {
		//3.创建线程One
		Thread threadOne=new Thread(new Runnable() {
			
			@Override
			public void run() {
				//3.1 设置One中本地变量LocalVariable的值
				localVariable.set("threadOne local variable");
				//3.2 调用打印函数
				print("threadOne");
				//3.3 打印本地变量值
				System.out.println("threadOne remove after:"+localVariable.get());
				
			}
		});
		//4.创建线程Two
		Thread threadTwo=new Thread(new Runnable() {
			
			@Override
			public void run() {
				//4.1 设置One中本地变量LocalVariable的值
				localVariable.set("threadTwo local variable");
				//4.2 调用打印函数
				print("threadTwo");
				//4.3 打印本地变量值
				System.out.println("threadTwo remove after:"+localVariable.get());
				
			}
		});
		
		//5.启动线程
		threadOne.start();
		threadTwo.start();
	}
}

代码(2)创建了一个ThreadLocal变量。

代码(3)和(4)分别创建了线程One和Two。

代码(5)启动了两个线程。

线程One的代码3.1通过set方法设置了localVariable的值,这其实设置的是线程One本地内存中的一个副本,这个副本线程Two访问不了的。然后代码3.2调用了print函数,代码1.1通过get函数获取了当前线程(线程One)本地内存中localVariable的值。线程Two执行类似于线程One。打开代码1.2的注释后,再次运行,运行结果如下。

1.2 ThreadLocal的实现原理

先看一下ThreadLocal相关类的类图结构,如下图所示:

由该图可知,Thread类中有一个threadLocals和一个inheritableThreadLocals,它们都是ThreadLocalMap类型的变量,而ThreadLocalMap是一个定制化的Hashmap。在默认情况下,每个线程中的这两个变量都为null,只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们。其实每个线程的本地变量不是存放在ThreadLocal例里面,而是存放在调用线程的threadLocals变量里面。也就是说,ThreadLocal类型的本地变量存放在具体的线程内存空间中。ThreadLocal就是一个工具壳,它通过set方法把value值放入调用线程的threadLocals里并存放起,当调用线程调用它的get方法时,再从当前线程的threadLocals变量里面将其拿出来使用。如果调用线程一直不终止,那么这个本地变量会一直存放在调用线程的threadLocals变量里面,所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove法,从当前线程的threadLocals里面删除该本地变量。另外,Thread里面的threadLocals为何被设计为map结构?很明显是因为每个线程可以关联多个ThreadLocal变量。

下面简单分析ThreadLocal的set、get及remove方法的实现逻辑。

1.void set(T value)

        public void set(T value) {
            1.获取当前线程
            Thread t = Thread.currentThread();
            2.将当前线程作为key,去查找对应的线程变量,找到则设置
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                3.第一次调用就创建线程所对应的hashMap
                createMap(t, value);
        }

代码1首先获取调用线程,然后使用当前线程作为参数调用getMap(t)方法,getMap(Threadt)的代码如下。

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

可以看到,getMap(t)的作用是获取线程自己的变量threadLocals,threadlocal量被绑定到了线程的成员变量上。如果getMap(t)的返回值不为空,则把value值设置到threadLocals中,也就是把当前变量值放入当前线程的内存变量threadLocals中。threadLocals是一个hashMap结构,其中key就是当前ThreadLocal的实例对象引用,value是通过set方法传递的值。如果getMap(t)返回空值则说明是第一次调用set方法,这时创建当前线程的threadLocals变量。下面来看createMap(t,value)做什么。

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

它创建当前线程的ThreadLocals变量

2. T get()

	public T get() {
	      4.获取当前线程
		  Thread t = Thread.currentThread();
	      5.获取当前线程的ThreadLocals变量
		  ThreadLocalMap map = getMap(t);
	      6.如果ThreadLocals不为null,则返回对应的本地变量的值
		  if (map != null) {
		      ThreadLocalMap.Entry e = map.getEntry(this);
		      if (e != null) {
		          @SuppressWarnings("unchecked")
		          T result = (T)e.value;
		          return result;
		      }
		  }
	      7.如果ThreadLocals为空则初始化当前线程的ThreadLocals成员变量
		  return setInitialValue();
		}

代码4首先获取当前线程实例,如果当前线程的threadLocals变量不为null,则直接返回当前线程绑定的本地变量,否则执行代码7进行初始化。setinitialValue()的码如下:

	  private T setInitialValue() {
	        8.初始化为null
	        T value = initialValue();
	        Thread t = Thread.currentThread();
	        ThreadLocalMap map = getMap(t);
	        9.如果当前线程的ThreadLocals变量不为空
	        if (map != null)
	            map.set(this, value);
	        else
	        10.如果当前线程的ThreadLocals变量不为空
	            createMap(t, value);
	        return value;
	    }

如果当前线程的threadLocals变量不为空,则设置当前线程的本地变量值为null,否则调用createMap法创建当前线程的createMap量。

3. void remove()

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

以上代码所示,如果当前线程的threadLocals变量不为空,则删除当前线程中指定ThreadLocal实例的本地变量。

总结:如下图所示:

在每个线程内部都有一个名为threadLocals的成员变量,该变量的类型为HashMap,其中key为我们定义的ThreadLocal变量的this引用,value则为我们使用set方法设置的值。每个线程的本地变量存放在线程自己的内存变量threadLocals中,如果当前线程一直不消亡,那么这些本地变量会一直存在,所以可能会造成内存溢出,因此使用完毕后要记得调用ThreadLocal的remove方法删除对应线程的threadLocals中的本地变量。在JUC包里面的ThreadLocalRandom,就是借鉴ThreadLocal的思想实现的。

1.3 ThreadLocal不支持继承性

首先看一个例子:

public class ThreadLocalTest2 {
	 //创建线程变量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        //父线程中设置线程变量
        threadLocal.set("hello world");

        //启动子线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //子线程输出线程变量的值
                System.out.println("thread:" + threadLocal.get());
            }
        });

        thread.start();

        System.out.println("main:" + threadLocal.get());
    }
}

就是说,同一个ThreadLocal变量在父线程中被设置值后,在子线程中是获取不到的。根据上节的介绍,这应该是正常现象,因为在子线程thread里面调用get方法时当前线程为thread线程,而这里调用set方法设置线程变量的是main线程,两者是不同的线程,自然子线程访问时返回null。那么有没有办法让子线程能访问到父线程中的值?答案是有。

1.4 InheritableThreadLocal 类

为了解决上节提出的问题,InheritableThreadLocal应运而生。InheritableThreadLocal继承自ThreadLocal,其提供了一个特性,就是让子线程可以访问在线程中设置的本地变量。下面看一下InheritableThreadLocal的代码:

	public class InheritableThreadLocal<T> extends ThreadLocal<T> {
	      1.
      protected T childValue(T parentValue) {
	        return parentValue;
	    }
       2.
	    ThreadLocalMap getMap(Thread t) {
	       return t.inheritableThreadLocals;
	    }
	     3.
	    void createMap(Thread t, T firstValue) {
	        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
	    }
	}

由如上代码可知,InheritabIeThreadLocal继承了ThreadLocal,并重写了三个方法。

由代码3可知,InheritableThreadLocal重写了createMap方法,那么现在当第一次调用set方法时,创建的是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals。

由代码2可知,当调用get方法获取当前线程内部的map变量时,获取的是inheritableThreadLocals而不再是threadLocals。

综上可知,在InheritableThreadLocal的世界里,变量inheritableThreadLocals替代了threadLocals。

下面我们看一下重写的代码1何时执行,以及如何让子线程可以访问父线程的本地变量。这要从创建Thread的代码说起,打开Thread类的默认构造函数,代码如下。

 public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
			private void init(ThreadGroup g, Runnable target, String name,
			                long stackSize, AccessControlContext acc,
			                boolean inheritThreadLocals) {
			  if (name == null) {
			      throw new NullPointerException("name cannot be null");
			  }
			
			  this.name = name;
			   4.获取当前线程
			  Thread parent = currentThread();
			  SecurityManager security = System.getSecurityManager();
			  if (g == null) {
			      /* Determine if it's an applet or not */
			
			      /* If there is a security manager, ask the security manager
			         what to do. */
			      if (security != null) {
			          g = security.getThreadGroup();
			      }
			
			      /* If the security doesn't have a strong opinion of the matter
			         use the parent thread group. */
			      if (g == null) {
			          g = parent.getThreadGroup();
			      }
			  }
			
			  /* checkAccess regardless of whether or not threadgroup is
			     explicitly passed in. */
			  g.checkAccess();
			
			  /*
			   * Do we have the required permissions?
			   */
			  if (security != null) {
			      if (isCCLOverridden(getClass())) {
			          security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
			      }
			  }
			
			  g.addUnstarted();
			
			  this.group = g;
			  this.daemon = parent.isDaemon();
			  this.priority = parent.getPriority();
			  if (security == null || isCCLOverridden(parent.getClass()))
			      this.contextClassLoader = parent.getContextClassLoader();
			  else
			      this.contextClassLoader = parent.contextClassLoader;
			  this.inheritedAccessControlContext =
			          acc != null ? acc : AccessController.getContext();
			  this.target = target;
			  setPriority(priority);
               5.如果父线程的inheritableThreadLocals变量不为null
			  if (inheritThreadLocals && parent.inheritableThreadLocals != null)
			      this.inheritableThreadLocals =
                    6.设置子线程的inheritableThreadLocals变量
			          ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
			  /* Stash the specified stack size in case the VM cares */
			  this.stackSize = stackSize;
			
			  /* Set thread ID */
			  tid = nextThreadID();
			}

如上代码在创建线程时,在构造函数里面会调用init方法。代码4获取了当前线程(这里是指main函数在的线程,也就是父线程〉,然后代码5判断main函数所在线程里面的inheritableThreadLocals属性是否为null,前面我们讲了InheritableThreadLocal类的get和set方法操作的是inheritableThreadLocals,所以这里的inheritableThreadLocal变量不为null,因此会执行代码6。下面看一下createlnheritedMap的代码:

   static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

可以看到,在createlnheritedMap内部使用父线程的inheritableThreadLocals变量作为构造函数创建了一个新的ThreadLocamap变量,然后赋值给了子线程的inheritableThreadLocals变量。下面我们看看在ThreadLocalMap的构造函数内部都做了什么事情:

        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        7.调用重写的方法
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

在该构造函数内部把父线程的inheritableThreadLocals成员变量的值复制到新的ThreadLocalMap对象,其中代码7调用了InheritableThreadLocal类重的代码1。

总结:InheritableThreadLocal类通过重写代码2和3让本地变量保存到了具体线程的inheritableThreadLocals变量里面,那么线程在通过InheritableThreadLocal类实例的set或者get法设置变量时,就会创建当前线程的inheritableThreadLocals变量。当父线程创建子线程时,构造函数会把父线程中inheritableThreadLocals变量里面的本地变量复制一份保存到子线程的inheritableThreadLocals变量里面。

把1.3节中的代码修改为:

public static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

可见,现在可以从子线程正常获取到线程变量的值了。

那么在什么情况下需要子线程可以获取父线程的threadlocal变量呢?情况还是蛮多的,比如子线程需要使用存放在threadlocal量中的用户登录信息,再比如一些中间件需要把统一的id追踪的整调用链路记录下来。其实子线程使用父线程中的threadlocal方法有多种方式,比如创建线程时传入父线程中的变量,并将其复制到子线程中,或者在父线程中构造一个map作为参数传递给子线程,但是这些都改变了我们的使用习惯,所以在这些情况下InheritabIeThreadLocal就显得比较有用。

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值