ThreadLocal的细节和设计模式
提要：
1.都知道ThreadLocal都是线程局部变量，可以比作是个Thread->T的MAP，那么有个问题了，如果一个类维护了一个TL的局部变量，随着不同的线程访问，这个TL会变得很大么？我们需要在线程结束前调用TL.remove来删除TL变量么，如果不删除会不会空间无法释放导致OOM呢？
2.在写某些会被多线程访问的代码时，某些实例变量需要做成线程私有，那么就会出现在使用这些变量时都使用threadLocal.get(),这样的junk code,有好的代码结构可以优化他么？
============================================================================
解答：
1.其实ThreadLocal并不把变量保存在自己里，而是保存到线程t里，
摘自ThreadLocal
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 getMap(Thread t) {
return t.threadLocals;
}
摘自Thread
ThreadLocal.ThreadLocalMap threadLocals = null;
因此，TheadLocal本身并不保存变量，而是委托线程去保存。而这里又有个问题，这样做可以保证ThreadLocal不会受到线程的生命周期影响，我们也不需要显示remove。那么这里又有个问题了，线程Map里始终维护了TheadLocal->T的变量，如果维护ThreadLocal的对象被GC掉，线程本地变量里的ThreadLocal变量却依然被引用，并不会被gc。这样会不会有内存泄露呢？
实际上是不会的，这个归功于WeakReference的使用
WeakReference是一种引用容器，他虽然会维持R的引用，但是如果除了WeakReference外没有其他Object引用R，那么weakreference会在R被GC时，删除他。
所以回到ThreadLocal，如果已经没有对象引用ThreadLocal，那么线程中的ThreadLocaMap就会踢掉这个被回收的ThreadLocal。
详见Thread.ThreadLocalMap
static class ThreadLocalMap {
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
.....
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
}
可以看到Entry是一个TheadLocal的弱引用,其成员变量保存了映射的value,Entry[]是线程的所有ThreadLocal变量。类似一个LinkedHashMap。
2.如何避免使用ThreadLocal的线程安全类满屏的t.get()这样的junkcode
在Ibatis中sqlMapClient配置为一个bean，但是每个线程在使用smc时总有自己的局部变量，例如Transaction,这样就跟我们的场景一样。但是我们并没有看到sqlMapClient使用t.get()这样的代码。他是怎么做到的呢：
如图，sqlMapClient是全局共享的，他的queryForObject其实是委托一个sqlMapSessionImpl实现的，
sqlMapSessionImpl是线程成私有的，保存在smc的TheadLocal变量里的。
摘自SqlMapClient
protected SqlMapSessionImpl getLocalSqlMapSession() {
SqlMapSessionImpl sqlMapSession = (SqlMapSessionImpl) localSqlMapSession.get();
if (sqlMapSession == null || sqlMapSession.isClosed()) {
sqlMapSession = new SqlMapSessionImpl(this);
localSqlMapSession.set(sqlMapSession);
}
return sqlMapSession;
}
而sqlMapSessionImpl作为一个实例变量，他是不可能完成数据库操作的，他是委托了SqlMapExecutorDelegate的方法，SMED是在sqlMapClient里的变量，可以理解为是变相的回调操作。而SMSI里维护了一个SessionScope，这个是一个线程上下文里的变量，
摘自SqlMapSessionImpl
public class SqlMapSessionImpl implements SqlMapSession {
protected SqlMapExecutorDelegate delegate;
protected SessionScope sessionScope;
protected boolean closed;
...
}
摘自SessionScope
public class SessionScope {
private static long nextId;
private long id;
// Used by Any
private SqlMapClient sqlMapClient;
private SqlMapExecutor sqlMapExecutor;
private SqlMapTransactionManager sqlMapTxMgr;
private int requestStackDepth;
// Used by TransactionManager
private Transaction transaction;
private TransactionState transactionState;
...
} SqlMapExecutorDelegate才是数据库执行的真正地方，那么既然要实现线程安全的操作，势必有个SqlMapExecutorDelegate不能再维护TheadLocal变量了，因此SqlMapExecutorDelegate的操作都带有SessionScope这个入参。
摘自SqlMapExecutorEelegate
public Object queryForObject(SessionScope sessionScope, String id, Object paramObject) throws SQLException {
return queryForObject(sessionScope, id, paramObject, null);
} 因此通过这样的回调，巧妙的解决了junkcode,让代码更加清晰。
================================================================================
模仿一下
我们需要抽象一个数据源DataProvider，DataProvider可以有很多实现类，例如FileDataProvider,MysqlDataProvider,这个DataProvider数据的获取方式变成Iterator的方式。
public abstract class DataProvider implements Iterator<Row> {
public abstract Set<String> listFieldsName();
public abstract Long size();
public abstract void setPath(String path);
public String getName() {
return this.getClass().toString();
}
public abstract String getDesc();
public void remove() {
throw new UnsupportedOperationException();
}
}
那么junk-code的写法（代码只截取部分，有个意思）
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;
@Component
public class FileDataProvider extends DataProvider {
private ThreadLocal<ReaderInfo> readerInfo = new ThreadLocal<ReaderInfo>();
class ReaderInfo {
public String csvFullPath = null;
public BufferedReader reader = null;
public File file = null;
public boolean hasMore = false;
public boolean isColumn = true;
public List<String> columnNameList = null;
}
public boolean hasNext() {
try {
if (readerInfo.get().file == null)
readerInfo.get().file = new File(readerInfo.get().csvFullPath);
if (readerInfo.get().reader == null)
readerInfo.get().reader = new BufferedReader(new FileReader(readerInfo.get().file));
if (readerInfo.get().reader.ready()) {
readerInfo.get().hasMore = true;
if (readerInfo.get().isColumn) {
readerInfo.get().isColumn = false;
readerInfo.get().columnNameList = new ArrayList<String>();
String line = readerInfo.get().reader.readLine();
StringTokenizer st = new StringTokenizer(line, ",");
while (st.hasMoreTokens()) {
readerInfo.get().columnNameList.add(st.nextToken());
}
}
return true;
} else {
readerInfo.get().hasMore = false;
readerInfo.get().reader.close();
readerInfo.get().reader = null;
return false;
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
...
}
在hashNext中需要访问readerInfo里的path和file都用到了readerInfo.get()。
-------------以下是模仿sqlMapClient做的改造--------------------
1.把readerfino独立出来（变个名字sessionScope）
public class SessionScope {
public String csvFullPath = null;
public BufferedReader reader = null;
public File file = null;
public boolean hasMore = false;
public boolean isColumn = true;
public List<String> columnNameList = null;
}
2.编写一个使用sessionScope作为入参的读取器FileProviderExecutor
import com.alibaba.cainiao.hellomaven.impl.Field;
import com.alibaba.cainiao.hellomaven.impl.Row;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
public class FileProviderExecutor {
public boolean hasNext(SessionScope sessionScope) {
try {
if (sessionScope.file == null)
sessionScope.file = new File(sessionScope.csvFullPath);
if (sessionScope.reader == null)
sessionScope.reader = new BufferedReader(new FileReader(sessionScope.file));
if (sessionScope.reader.ready()) {
sessionScope.hasMore = true;
if (sessionScope.isColumn) {
sessionScope.isColumn = false;
sessionScope.columnNameList = new ArrayList<String>();
String line = sessionScope.reader.readLine();
StringTokenizer st = new StringTokenizer(line, ",");
while (st.hasMoreTokens()) {
sessionScope.columnNameList.add(st.nextToken());
}
}
return true;
} else {
sessionScope.hasMore = false;
sessionScope.reader.close();
sessionScope.reader = null;
return false;
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
...
}
3.写一个FileDataSessionProvider，维护sessionScope,和FileProviderExecutor，FPE使用构造函数传递进来（当然也可以吧FPE换成FileDataProvider）
public class FileDataSessionProvider {
private SessionScope sessionScope;
private FileProviderExecutor fileProviderExecutor = null;
public FileDataSessionProvider(FileProviderExecutor executor) {
this.fileProviderExecutor = executor ;
sessionScope = new SessionScope();
}
public Set<String> listFieldsName() {
return fileProviderExecutor.listFieldsName(sessionScope);
}
public Long size() {
return fileProviderExecutor.size(sessionScope);
}
public void setPath(String path) {
this.sessionScope.csvFullPath = path;
}
public boolean hasNext() {
return fileProviderExecutor.hasNext(sessionScope);
}
public Row next() {
return fileProviderExecutor.next(sessionScope);
}
}
所有的函数委托Executor执行，传入参数sessionScope
4.最后，封装FileDataProvider，维护一个TheadLocal变量，里面存放FileDataSessionProvider,实现DataProvider，获取TheadLocal变量进行调用。
public class FileDataProvider extends DataProvider {
FileProviderExecutor fileProviderExecutor = new FileProviderExecutor();
private ThreadLocal<FileDataSessionProvider> fileDataSessionProviderThreadLocal = new ThreadLocal<FileDataSessionProvider>();
private FileDataSessionProvider getLocalSessionProvider() {
FileDataSessionProvider fileDataSessionProvider = fileDataSessionProviderThreadLocal.get();
if (fileDataSessionProvider == null) {
fileDataSessionProvider = new FileDataSessionProvider(this.fileProviderExecutor);
fileDataSessionProviderThreadLocal.set(fileDataSessionProvider);
}
return fileDataSessionProvider;
}
@Override
public Set<String> listFieldsName() {
return this.getLocalSessionProvider().listFieldsName();
}
@Override
public Long size() {
return this.getLocalSessionProvider().size();
}
@Override
public void setPath(String path) {
this.getLocalSessionProvider().setPath(path);
}
@Override
public String getDesc() {
return "测试下";
}
public boolean hasNext() {
return this.getLocalSessionProvider().hasNext();
}
public Row next() {
return this.getLocalSessionProvider().next();
}
public FileProviderExecutor getFileProviderExecutor() {
return fileProviderExecutor;
}
public void setFileProviderExecutor(FileProviderExecutor fileProviderExecutor) {
this.fileProviderExecutor = fileProviderExecutor;
}
}
在getLocalSessionProvider()中，如果该线程没有访问过就创建sessionProvider，传入Executor。这样就完成了封装，绕过了对ThreadLocal变量内部成员变量的反复读取。这样的设计模式让代码层次更清晰，但是呢缺增加了代码量和理解难度，所以可以看情况选择使用。
不过这样的写法在设计模式里能找到对应的类型么？
FINISH