【java】【并发编程】线程封闭

线程封闭

当访问共享的可变数据时，通常需要使用同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程内访问数据，就不需要同步。这种技术被称为线程封闭。

栈封闭

局部变量的固有属性之一就是封闭在线程中。它们位于执行线程的栈中，其他线程无法访问这个栈。

public int loadTheArk(Collection<Animal> candidates){
    SortedSet<Animal> animals;
    int numPairs = 0;
    Animal candidates = null;
    //animals被封闭在方法中，不要使它们逸出
    animals = new TreeSet<Animal>(new SpeciesGenderComparator());
    animals.addAll(candidates);
    for (Animal a : animals) {
        if (candidates == null || !candidates.isPotentialMate(a)) {
            candidates = a;
        } else {
            ark.load(new AnimalPair(candidates,a));
            ++numPairs;
            candidates = null;
        }
    }
    return numPairs;
}

如上例子，我们将animals封闭在方法中，使得它在每个线程都是独有的，而不是共享的。

ThreadLocal类

ThreadLocal类为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的绑定机制，是每一个线程都可以独立地改变自己的副本，而不会与其他副本冲突。

• ThreadLocal如何为每一个线程维护变量的副本？
  在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

• 对于多线程资源问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供了一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

public class TestNum {
    //初始化
    private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){
        public Integer initialValue() {
            return 0;
        }
    };

    public int getNextNum(){
        seqNum.set(seqNum.get()+1);
        return seqNum.get();
    }

    public static void main(String[] args) {
        TestNum sn = new TestNum();

        //三个线程共享SN 产生序列号
        ThreadClient t1 = new ThreadClient(sn);
        ThreadClient t2 = new ThreadClient(sn);
        ThreadClient t3 = new ThreadClient(sn);
        t1.start();
        t2.start();
        t3.start();
    }
}

class ThreadClient extends Thread{
    private TestNum sn ;

    public ThreadClient(TestNum sn){
        this.sn = sn;
    }
    public void run(){
        for(int i = 0 ; i < 3 ; i++){
            System.out.println("Thread: "+ Thread.currentThread().getName()
                    + " sn: " + sn.getNextNum());
        }
    }
}

运行结果：
Thread: Thread-1 sn: 1
Thread: Thread-0 sn: 1
Thread: Thread-2 sn: 1
Thread: Thread-2 sn: 2
Thread: Thread-0 sn: 2
Thread: Thread-1 sn: 2
Thread: Thread-1 sn: 3
Thread: Thread-0 sn: 3
Thread: Thread-2 sn: 3

如上，我们可以看到三个线程之间的数据都是相互独立的。

再比如在多个线程对连接数据库的操作时：

private static ThreadLocal<Connection> connectionHolder 
    = new ThreadLocal<Connection>(){
        public Connection initialValue(){
            return DriverManager.getConnection(DB_URL);
        }
    };

public static Connection getConnection(){
    return connectionHolder.get();
}