Java多线程 -- 07 线程相关类

导读目录

• ThreadLocal类
• Collections(包装不安全的集合)

1.ThreadLocal类

该类是Thread Local Variable(线程局部变量)的意思。ThreadLocal为解决多线程程序的并发问题提供了一种新的思路：如果一个资源会引起线程竞争，那就为每一个线程配备一个资源

其功能很简单，就是为一个使用该变量的线程都提供一个变量的副本，是每一个线程都可以独立的去改变自己的副本，而不会和其他线程的副本冲突。

通过该类可以简化多线程编程时的并发访问，它可以很简捷地隔离多线程程序的竞争资源

该类提供如下方法：
T get(); //返回此线程局部变量中当前线程副本中的值
void remove(); //删除此线程局部变量中当前线程副本中的值
void set(T value); //设置此线程局部变量中当前线程副本中的值

ThreadLocal和其他的同步机制一样，都是为了解决多线程中对同一变量的访问冲突，只是在前面讲的同步机制中，是采用对象加锁来实现多个线程对同一个变量的安全访问。系统并没有将份资源进行复制多分，只是采用了安全机制来控制对这份资源的访问而已。

ThreadLocal将需要被并发访问的资源复制多分，使每个线程都拥有一份资源(是资源的副本)，这样也就没有必要对该变量进行同步了

ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象与线程相关的状态使用ThreadLocal保存、

//将Account对象封装进ThreadLocal中，注意体会
class Account {
    /* 定义一个ThreadLocal类型的变量，该变量将是一个线程局部变量
    每个线程都会保留该变量的一个副本 */
    private ThreadLocal<String> name = new ThreadLocal<String>();
    // 定义一个初始化name成员变量的构造器
    public Account(String str) {
        this.name.set(str);
        // 下面代码用于访问当前线程的name副本的值
        System.out.println("---" + this.name.get());
    }
    // name的setter和getter方法
    public String getName()
    {
        return name.get();
    }
    public void setName(String str)
    {
        this.name.set(str);
    }
}
class MyTest extends Thread
{
    // 定义一个Account类型的成员变量
    private Account account;
    public MyTest(Account account, String name)
    {
        super(name);
        this.account = account;
    }
    public void run()
    {
        // 循环10次
        for (int i = 0 ; i < 10 ; i++)
        {
            // 当i == 6时输出将账户名替换成当前线程名
            if (i == 6)
            {
                account.setName(getName());
            }
            // 输出同一个账户的账户名和循环变量
            System.out.println(account.getName()
                + " 账户的i值：" + i);
        }
    }
}
public class ThreadLocalTest
{
    public static void main(String[] args)
    {
        // 启动两条线程，两条线程共享同一个Account
        Account at = new Account("初始名");
        /*
        虽然两条线程共享同一个账户，即只有一个账户名
        但由于账户名是ThreadLocal类型的，所以每条线程
        都完全拥有各自的账户名副本，所以从i == 6之后，将看到两条
        线程访问同一个账户时看到不同的账户名。
        */
        new MyTest(at , "线程甲").start();
        new MyTest(at , "线程乙").start ();
    }
}

运行结果：

---初始名
null 账户的i值：0
null 账户的i值：1
null 账户的i值：0
null 账户的i值：2
null 账户的i值：1
null 账户的i值：3
null 账户的i值：2
null 账户的i值：4
null 账户的i值：3
null 账户的i值：5
null 账户的i值：4
线程甲 账户的i值：6
null 账户的i值：5
线程甲 账户的i值：7
线程乙 账户的i值：6
线程甲 账户的i值：8
线程乙 账户的i值：7
线程乙 账户的i值：8
线程甲 账户的i值：9
线程乙 账户的i值：9

TreadLocal类为什么能做到为每个线程提供不同的变量拷贝？
其set(T value)方法的源码：

public void set(T value) {  
    Thread t = Thread.currentThread();  
    ThreadLocalMap map = getMap(t);  
    if (map != null)  
         map.set(this, value);  
    else  
        createMap(t, value);  
    }
}

线程隔离的秘密，就在于ThreadLocalMap这个类。ThreadLocalMap是ThreadLocal类的一个静态内部类，它实现了键值对的设置和获取(对比Map对象来理解)，每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。

为了加深理解，我们接着看上面代码中出现的getMap和createMap方法的实现：

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

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

接下来再看一下ThreadLocal类中的get()方法:

public T get() {  
    Thread t = Thread.currentThread();  
    ThreadLocalMap map = getMap(t);  
    if (map != null) {  
        ThreadLocalMap.Entry e = map.getEntry(this);  
        if (e != null)  
            return (T)e.value;  
    }  
    return setInitialValue();  
}  

获取当前线程绑定的值时，ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的，这当然和前面set()方法的代码是相呼应的。

详细见：
http://www.cnblogs.com/dolphin0520/p/3920407.html

2.Collections(包装不安全的集合)

以其中一个方法为例来看看其内部是如何实现包装的？(即包装成安全类)

synchronizedSet方法，用于将不安全的Set集合包装成安全的集合

public static <T> Set<T> synchronizedSet(Set<T> s) {
    return new SynchronizedSet<>(s);
}

SynchronizedSet是Collections的一个内部类

static class SynchronizedSet<E>
      extends SynchronizedCollection<E>
      implements Set<E> {
    private static final long serialVersionUID = 487447009682186044L;

    SynchronizedSet(Set<E> s) {
        super(s);
    }
    SynchronizedSet(Set<E> s, Object mutex) {
        super(s, mutex);
    }

    public boolean equals(Object o) {
        if (this == o)
            return true;
        synchronized (mutex) {return c.equals(o);}
    }
    public int hashCode() {
        synchronized (mutex) {return c.hashCode();}
    }
}

再看看其父类的SynchronizedCollection<E>的源码：

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
    private static final long serialVersionUID = 3053995032091335093L;

    final Collection<E> c;  // Backing Collection
    final Object mutex;     // Object on which to synchronize

    SynchronizedCollection(Collection<E> c) {
        this.c = Objects.requireNonNull(c);//就是让这里的Collection指向传进来的Collection,这么写只是辨识了是否为null
        mutex = this;//同步监视器, 即当前对象
    }

    /*Objects的requireNonNull()方法
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

    */

    SynchronizedCollection(Collection<E> c, Object mutex) {
        this.c = Objects.requireNonNull(c);
        this.mutex = Objects.requireNonNull(mutex);
    }

    public int size() {
        synchronized (mutex) {return c.size();}
    }
    public boolean isEmpty() {
        synchronized (mutex) {return c.isEmpty();}
    }
    public boolean contains(Object o) {
        synchronized (mutex) {return c.contains(o);}
    }
    public Object[] toArray() {
        synchronized (mutex) {return c.toArray();}
    }
    public <T> T[] toArray(T[] a) {
        synchronized (mutex) {return c.toArray(a);}
    }

    public Iterator<E> iterator() {
        return c.iterator(); // Must be manually synched by user!
    }

    public boolean add(E e) {
        synchronized (mutex) {return c.add(e);}
    }
    public boolean remove(Object o) {
        synchronized (mutex) {return c.remove(o);}
    }

    public boolean containsAll(Collection<?> coll) {
        synchronized (mutex) {return c.containsAll(coll);}
    }
    public boolean addAll(Collection<? extends E> coll) {
        synchronized (mutex) {return c.addAll(coll);}
    }
    public boolean removeAll(Collection<?> coll) {
        synchronized (mutex) {return c.removeAll(coll);}
    }
    public boolean retainAll(Collection<?> coll) {
        synchronized (mutex) {return c.retainAll(coll);}
    }
    public void clear() {
        synchronized (mutex) {c.clear();}
    }
    public String toString() {
        synchronized (mutex) {return c.toString();}
    }
    // Override default methods in Collection
    @Override
    public void forEach(Consumer<? super E> consumer) {
        synchronized (mutex) {c.forEach(consumer);}
    }
    @Override
    public boolean removeIf(Predicate<? super E> filter) {
        synchronized (mutex) {return c.removeIf(filter);}
    }
    @Override
    public Spliterator<E> spliterator() {
        return c.spliterator(); // Must be manually synched by user!
    }
    @Override
    public Stream<E> stream() {
        return c.stream(); // Must be manually synched by user!
    }
    @Override
    public Stream<E> parallelStream() {
        return c.parallelStream(); // Must be manually synched by user!
    }
    private void writeObject(ObjectOutputStream s) throws IOException {
        synchronized (mutex) {s.defaultWriteObject();}
    }
}

很明显，原来Collection中的所有方法都被放入同步代码块中。同步监视器为当前对象