线程以及ThreadLocal类

2016-12-04 本文已影响53人学不好语文的LJ码农

以下内容整理自互联网，仅用于个人学习

线程的创建和启动

继承Thread类
定义Thread的子类，重写run方法，创建该子类的实例调用start方法。
实现Runnable接口
定义Runnable接口的实现类，重写run方法，创建该实现类的实例并将实例作为参数来创建Thread对象，再调用Thread对象的start方法。
实现Callable接口（不常用）
实现Callable接口，重写call方法。
Callable接口比Runnable接口更加强大，Callable接口提供一个返回值，call方法能抛出异常，这些都是Runnable接口没有的功能。

实现Runnable接口相比继承Thread的优势：
1.可以避免单继承的局限性。
2.代码能被多个程序共享，代码与数据是独立的。
3.适合多个相同程序代码的线程去处理同一资源的情况。

ThreadLocal类

它代表一个线程局部变量，为每一个使用该变量的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。

ThreadLocal类的使用

ThreadLocal实例通常是类中的private static字段，它们希望将状态与某一个线程相关联。只要线程是活动的并且ThreadLocal实例是可访问的，每个线程都保持对其线程局部变量副本的隐式引用，在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

首先创建ThreadLocal对象，然后在线程中调用set和get方法来设置和获取值。

ThreadLocal<Integer> mValue = new ThreadLocal<Integer>();
mValue.set(1); 
int value = mValue.get();

ThreadLocal的接口方法

/** 
 * 返回此线程局部变量的初始值 
 * 
 * 线程第一次使用 get() 方法访问变量时将调用此方法，但如果线程之前调用 
 * 了 set(T) 方法，则不会对该线程再调用 initialValue 方法。通常，此 
 * 方法对每个线程最多调用一次，但如果在调用 get() 后又调用了  
 * remove()，则可能再次调用此方法。 
 *  
 * 该实现返回 null；如果程序员希望线程局部变量具有 null 以外的值，则 
 * 必须为 ThreadLocal 创建子类，并重写此方法。通常将使用匿名内部类完 
 * 成此操作。 
*/ 
protected T initialValue(); 
 
/** 
* 返回此线程局部变量的当前线程的值 
*  
* 如果变量没有用于当前线程的值，则先 
* 将其初始化为调用initialValue() 方法返回的值。 
*/ 
public T get(); 
 
/** 
* 将此线程局部变量的当前线程副本中的值设置为指定值 
*  
* 大部分子类不需要重写此方法，它们只依靠 initialValue() 方法 
* 来设置线程局部变量的值 
*/ 
public void set(T value); 
 
/** 
* 移除此线程局部变量当前线程的值 
*  
* 如果此线程局部变量随后被当前线程 读取，且这期间当前线程没有 
* 设置其值，则将调用其 initialValue() 方法重新初始化其值。 
* 这将导致在当前线程多次调用 initialValue 方法。 
*/ 
public void remove();

ThreadLocal实现线程安全

因为每个Thread在进行对象访问时,访问的都是各自线程自己的ThreadLocalMap，所以保证了Thread与Thread之间的数据访问隔离。
不同的ThreadLocal实例操作同一Thread时，ThreadLocalMap在存储时采用当前ThreadLocal的实例作为key来保证数据访问隔离。

public class Test{ 
    static ThreadLocal<Integer> local=new ThreadLocal<Integer>(){ 
        protected synchronized Integer initialValue(){   
            return 0;   
        } 
    };   
 
    public static void main( String args[]){ 
         testRun t = new testRun(); 
         new Thread(t).start(); 
         new Thread(t).start(); 
    } 
 
    public static  class testRun implements Runnable{ 
    @Override 
    public void run() { 
        // TODO Auto-generated method stub 
        for(int i=5 ;i>0;i--){ 
            try {   
                Thread.sleep(1000);   
            } catch (InterruptedException e) {   
                e.printStackTrace();   
            } 
            System.out.println(Thread.currentThread().getName()+"::"+local.get()); 
 
             int localValue=local.get();   
             local.set(++localValue);   
                }  
        } 
    }    
}

输出结果

Thread-0::0 
Thread-1::0 
Thread-0::1 
Thread-1::1 
Thread-1::2 
Thread-0::2 
Thread-1::3 
Thread-0::3 
Thread-0::4 
Thread-1::4

TheadLocal模式与同步机制的区别

实现机制
同步机制采用了“以时间换空间”的方式,提供一份变量,让不同的线程排队访问。
而ThreadLocal采用了“以空间换时间”的方式,为每一个线程都提供一份变量的副本,从而实现同时访问而互不影响。
同步共享
Java中的synchronized是一个保留字,它依靠JVM的锁机制来实现临界区的函数或者变量的访问中的原子性.在同步机制中,通过对象的锁机制保证同一时间只有一个线程访问变量.此时,被用作“锁机制”的变量是多个线程共享的；
而ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。
ThreadLocal不能代替同步机制，两者面向的问题领域不同。
使用场合
同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式。
而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。
所以，如果你需要进行多个线程之间进行通信，则使用同步机制。如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal。