Java多線程編程中ThreadLocal類的用法及深入
ThreadLocal，直譯為“線程本地”或“本地線程”，如果你真的這么認為，那就錯了！其實，它就是一個容器，用于存放線程的局部變量，我認為應該叫做 ThreadLocalVariable（線程局部變量）才對，真不理解為什么當初 Sun 公司的工程師這樣命名。
早在 JDK 1.2 的時代，java.lang.ThreadLocal 就誕生了，它是為了解決多線程并發(fā)問題而設計的，只不過設計得有些難用，所以至今沒有得到廣泛使用。其實它還是挺有用的，不相信的話，我們一起來看看這個例子吧。
一個序列號生成器的程序，可能同時會有多個線程并發(fā)訪問它，要保證每個線程得到的序列號都是自增的，而不能相互干擾。
先定義一個接口：
public interface Sequence {
int getNumber();
}
每次調(diào)用 getNumber() 方法可獲取一個序列號，下次再調(diào)用時，序列號會自增。
再做一個線程類：
public class ClientThread extends Thread {
private Sequence sequence;
public ClientThread(Sequence sequence) {
this.sequence = sequence;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + " => " + sequence.getNumber());
}
}
}
在線程中連續(xù)輸出三次線程名與其對應的序列號。
我們先不用 ThreadLocal，來做一個實現(xiàn)類吧。
public class SequenceA implements Sequence {
private static int number = 0;
public int getNumber() {
number = number + 1;
return number;
}
public static void main(String[] args) {
Sequence sequence = new SequenceA();
ClientThread thread1 = new ClientThread(sequence);
ClientThread thread2 = new ClientThread(sequence);
ClientThread thread3 = new ClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
序列號初始值是0，在 main() 方法中模擬了三個線程，運行后結(jié)果如下：
Thread-0 => 1 Thread-0 => 2 Thread-0 => 3 Thread-2 => 4 Thread-2 => 5 Thread-2 => 6 Thread-1 => 7 Thread-1 => 8 Thread-1 => 9
由于線程啟動順序是隨機的，所以并不是0、1、2這樣的順序，這個好理解。為什么當 Thread-0 輸出了1、2、3之后，而 Thread-2 卻輸出了4、5、6呢？線程之間竟然共享了 static 變量！這就是所謂的“非線程安全”問題了。
那么如何來保證“線程安全”呢？對應于這個案例，就是說不同的線程可擁有自己的 static 變量，如何實現(xiàn)呢？下面看看另外一個實現(xiàn)吧。
public class SequenceB implements Sequence {
private static ThreadLocal<Integer> numberContainer = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public int getNumber() {
numberContainer.set(numberContainer.get() + 1);
return numberContainer.get();
}
public static void main(String[] args) {
Sequence sequence = new SequenceB();
ClientThread thread1 = new ClientThread(sequence);
ClientThread thread2 = new ClientThread(sequence);
ClientThread thread3 = new ClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
通過 ThreadLocal 封裝了一個 Integer 類型的 numberContainer 靜態(tài)成員變量，并且初始值是0。再看 getNumber() 方法，首先從 numberContainer 中 get 出當前的值，加1，隨后 set 到 numberContainer 中，最后將 numberContainer 中 get 出當前的值并返回。
是不是很惡心？但是很強大！確實稍微饒了一下，我們不妨把 ThreadLocal 看成是一個容器，這樣理解就簡單了。所以，這里故意用 Container 這個單詞作為后綴來命名 ThreadLocal 變量。
運行結(jié)果如何呢？看看吧。
Thread-0 => 1 Thread-0 => 2 Thread-0 => 3 Thread-2 => 1 Thread-2 => 2 Thread-2 => 3 Thread-1 => 1 Thread-1 => 2 Thread-1 => 3
每個線程相互獨立了，同樣是 static 變量，對于不同的線程而言，它沒有被共享，而是每個線程各一份，這樣也就保證了線程安全。 也就是說，TheadLocal 為每一個線程提供了一個獨立的副本！
搞清楚 ThreadLocal 的原理之后，有必要總結(jié)一下 ThreadLocal 的 API，其實很簡單。
- public void set(T value)：將值放入線程局部變量中
- public T get()：從線程局部變量中獲取值
- public void remove()：從線程局部變量中移除值（有助于 JVM 垃圾回收）
- protected T initialValue()：返回線程局部變量中的初始值（默認為 null）
為什么 initialValue() 方法是 protected 的呢？就是為了提醒程序員們，這個方法是要你們來實現(xiàn)的，請給這個線程局部變量一個初始值吧。
了解了原理與這些 API，其實想想 ThreadLocal 里面不就是封裝了一個 Map 嗎？自己都可以寫一個 ThreadLocal 了，嘗試一下吧。
public class MyThreadLocal<T> {
private Map<Thread, T> container = Collections.synchronizedMap(new HashMap<Thread, T>());
public void set(T value) {
container.put(Thread.currentThread(), value);
}
public T get() {
Thread thread = Thread.currentThread();
T value = container.get(thread);
if (value == null && !container.containsKey(thread)) {
value = initialValue();
container.put(thread, value);
}
return value;
}
public void remove() {
container.remove(Thread.currentThread());
}
protected T initialValue() {
return null;
}
}
以上完全山寨了一個 ThreadLocal，其中中定義了一個同步 Map（為什么要這樣？請讀者自行思考），代碼應該非常容易讀懂。
下面用這 MyThreadLocal 再來實現(xiàn)一把看看。
public class SequenceC implements Sequence {
private static MyThreadLocal<Integer> numberContainer = new MyThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public int getNumber() {
numberContainer.set(numberContainer.get() + 1);
return numberContainer.get();
}
public static void main(String[] args) {
Sequence sequence = new SequenceC();
ClientThread thread1 = new ClientThread(sequence);
ClientThread thread2 = new ClientThread(sequence);
ClientThread thread3 = new ClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
以上代碼其實就是將 ThreadLocal 替換成了 MyThreadLocal，僅此而已，運行效果和之前的一樣，也是正確的。
其實 ThreadLocal 可以單獨成為一種設計模式，就看你怎么看了。
ThreadLocal 具體有哪些使用案例呢？
我想首先要說的就是：通過 ThreadLocal 存放 JDBC Connection，以達到事務控制的能力。
還是保持我一貫的 Style，用一個 Demo 來說話吧。用戶提出一個需求：當修改產(chǎn)品價格的時候，需要記錄操作日志，什么時候做了什么事情。
想必這個案例，只要是做過應用系統(tǒng)的小伙伴們，都應該遇到過吧？無外乎數(shù)據(jù)庫里就兩張表：product 與 log，用兩條 SQL 語句應該可以解決問題：
update product set price = ? where id = ? insert into log (created, description) values (?, ?)
But！要確保這兩條 SQL 語句必須在同一個事務里進行提交，否則有可能 update 提交了，但 insert 卻沒有提交。如果這樣的事情真的發(fā)生了，我們肯定會被用戶指著鼻子狂罵：“為什么產(chǎn)品價格改了，卻看不到什么時候改的呢？”。
聰明的我在接到這個需求以后，是這樣做的：
首先，我寫一個 DBUtil 的工具類，封裝了數(shù)據(jù)庫的常用操作：
public class DBUtil {
// 數(shù)據(jù)庫配置
private static final String driver = "com.mysql.jdbc.Driver";
private static final String url = "jdbc:mysql://localhost:3306/demo";
private static final String username = "root";
private static final String password = "root";
// 定義一個數(shù)據(jù)庫連接
private static Connection conn = null;
// 獲取連接
public static Connection getConnection() {
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
// 關閉連接
public static void closeConnection() {
try {
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
里面搞了一個 static 的 Connection，這下子數(shù)據(jù)庫連接就好操作了，牛逼吧！
然后，我定義了一個接口，用于給邏輯層來調(diào)用：
public interface ProductService {
void updateProductPrice(long productId, int price);
}
根據(jù)用戶提出的需求，我想這個接口完全夠用了。根據(jù) productId 去更新對應 Product 的 price，然后再插入一條數(shù)據(jù)到 log 表中。
其實業(yè)務邏輯也不太復雜，于是我快速地完成了 ProductService 接口的實現(xiàn)類：
public class ProductServiceImpl implements ProductService {
private static final String UPDATE_PRODUCT_SQL = "update product set price = ? where id = ?";
private static final String INSERT_LOG_SQL = "insert into log (created, description) values (?, ?)";
public void updateProductPrice(long productId, int price) {
try {
// 獲取連接
Connection conn = DBUtil.getConnection();
conn.setAutoCommit(false); // 關閉自動提交事務（開啟事務）
// 執(zhí)行操作
updateProduct(conn, UPDATE_PRODUCT_SQL, productId, price); // 更新產(chǎn)品
insertLog(conn, INSERT_LOG_SQL, "Create product."); // 插入日志
// 提交事務
conn.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 關閉連接
DBUtil.closeConnection();
}
}
private void updateProduct(Connection conn, String updateProductSQL, long productId, int productPrice) throws Exception {
PreparedStatement pstmt = conn.prepareStatement(updateProductSQL);
pstmt.setInt(1, productPrice);
pstmt.setLong(2, productId);
int rows = pstmt.executeUpdate();
if (rows != 0) {
System.out.println("Update product success!");
}
}
private void insertLog(Connection conn, String insertLogSQL, String logDescription) throws Exception {
PreparedStatement pstmt = conn.prepareStatement(insertLogSQL);
pstmt.setString(1, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
pstmt.setString(2, logDescription);
int rows = pstmt.executeUpdate();
if (rows != 0) {
System.out.println("Insert log success!");
}
}
}
代碼的可讀性還算不錯吧？這里我用到了 JDBC 的高級特性 Transaction 了。暗自慶幸了一番之后，我想是不是有必要寫一個客戶端，來測試一下執(zhí)行結(jié)果是不是我想要的呢？ 于是我偷懶，直接在 ProductServiceImpl 中增加了一個 main() 方法：
public static void main(String[] args) {
ProductService productService = new ProductServiceImpl();
productService.updateProductPrice(1, 3000);
}
我想讓 productId 為 1 的產(chǎn)品的價格修改為 3000。于是我把程序跑了一遍，控制臺輸出：
Update product success! Insert log success!
應該是對了。作為一名專業(yè)的程序員，為了萬無一失，我一定要到數(shù)據(jù)庫里在看看。沒錯！product 表對應的記錄更新了，log 表也插入了一條記錄。這樣就可以將 ProductService 接口交付給別人來調(diào)用了。
幾個小時過去了，QA 妹妹開始罵我：“我靠！我才模擬了 10 個請求，你這個接口怎么就掛了？說是數(shù)據(jù)庫連接關閉了！”。
聽到這樣的叫聲，讓我渾身打顫，立馬中斷了我的小視頻，趕緊打開 IDE，找到了這個 ProductServiceImpl 這個實現(xiàn)類。好像沒有 Bug 吧？但我現(xiàn)在不敢給她任何回應，我確實有點怕她的。
我突然想起，她是用工具模擬的，也就是模擬多個線程了！那我自己也可以模擬啊，于是我寫了一個線程類：
public class ClientThread extends Thread {
private ProductService productService;
public ClientThread(ProductService productService) {
this.productService = productService;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
productService.updateProductPrice(1, 3000);
}
}
我用這線程去調(diào)用 ProduceService 的方法，看看是不是有問題。此時，我還要再修改一下 main() 方法：
// public static void main(String[] args) {
// ProductService productService = new ProductServiceImpl();
// productService.updateProductPrice(1, 3000);
// }
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
ProductService productService = new ProductServiceImpl();
ClientThread thread = new ClientThread(productService);
thread.start();
}
}
我也模擬 10 個線程吧，我就不信那個邪了！
運行結(jié)果真的讓我很暈、很暈：
Thread-1 Thread-3 Thread-5 Thread-7 Thread-9 Thread-0 Thread-2 Thread-4 Thread-6 Thread-8 Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: No operations allowed after connection closed. at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27) at java.lang.reflect.Constructor.newInstance(Constructor.java:513) at com.mysql.jdbc.Util.handleNewInstance(Util.java:411) at com.mysql.jdbc.Util.getInstance(Util.java:386) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1015) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:989) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:975) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:920) at com.mysql.jdbc.ConnectionImpl.throwConnectionClosedException(ConnectionImpl.java:1304) at com.mysql.jdbc.ConnectionImpl.checkClosed(ConnectionImpl.java:1296) at com.mysql.jdbc.ConnectionImpl.commit(ConnectionImpl.java:1699) at com.smart.sample.test.transaction.solution1.ProductServiceImpl.updateProductPrice(ProductServiceImpl.java:25) at com.smart.sample.test.transaction.ClientThread.run(ClientThread.java:18)
我靠！竟然在多線程的環(huán)境下報錯了，果然是數(shù)據(jù)庫連接關閉了。怎么回事呢？我陷入了沉思中。于是我 Copy 了一把那句報錯信息，在百度、Google，還有 OSC 里都找了，解答實在是千奇百怪。
我突然想起，既然是跟 Connection 有關系，那我就將主要精力放在檢查 Connection 相關的代碼上吧。是不是 Connection 不應該是 static 的呢？我當初設計成 static 的主要是為了讓 DBUtil 的 static 方法訪問起來更加方便，用 static 變量來存放 Connection 也提高了性能啊。怎么搞呢？
于是我看到了 OSC 上非常火爆的一篇文章《ThreadLocal 那點事兒》，終于才讓我明白了！原來要使每個線程都擁有自己的連接，而不是共享同一個連接，否則線程1有可能會關閉線程2的連接，所以線程2就報錯了。一定是這樣！
我趕緊將 DBUtil 給重構(gòu)了：
public class DBUtil {
// 數(shù)據(jù)庫配置
private static final String driver = "com.mysql.jdbc.Driver";
private static final String url = "jdbc:mysql://localhost:3306/demo";
private static final String username = "root";
private static final String password = "root";
// 定義一個用于放置數(shù)據(jù)庫連接的局部線程變量（使每個線程都擁有自己的連接）
private static ThreadLocal<Connection> connContainer = new ThreadLocal<Connection>();
// 獲取連接
public static Connection getConnection() {
Connection conn = connContainer.get();
try {
if (conn == null) {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
connContainer.set(conn);
}
return conn;
}
// 關閉連接
public static void closeConnection() {
Connection conn = connContainer.get();
try {
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
connContainer.remove();
}
}
}
我把 Connection 放到了 ThreadLocal 中，這樣每個線程之間就隔離了，不會相互干擾了。
此外，在 getConnection() 方法中，首先從 ThreadLocal 中（也就是 connContainer 中） 獲取 Connection，如果沒有，就通過 JDBC 來創(chuàng)建連接，最后再把創(chuàng)建好的連接放入這個 ThreadLocal 中?？梢园?ThreadLocal 看做是一個容器，一點不假。
同樣，我也對 closeConnection() 方法做了重構(gòu)，先從容器中獲取 Connection，拿到了就 close 掉，最后從容器中將其 remove 掉，以保持容器的清潔。
這下應該行了吧？我再次運行 main() 方法：
Thread-0 Thread-2 Thread-4 Thread-6 Thread-8 Thread-1 Thread-3 Thread-5 Thread-7 Thread-9 Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success! Update product success! Insert log success!
總算是解決了
相關文章
這篇文章主要介紹了python中pass語句用法,對比C++程序?qū)嵗治隽藀ass語句的使用方法,具有一定參考借鑒價值,需要的朋友可以參考下2015-04-04
python+selenium+chromedriver實現(xiàn)爬蟲示例代碼
這篇文章主要介紹了python+selenium+chromedriver實現(xiàn)爬蟲示例代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-04-04
python3 中時間戳、時間、日期的轉(zhuǎn)換和加減操作
這篇文章主要介紹了python3 中時間戳、時間、日期的轉(zhuǎn)換和加減操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-07-07
語言是一種藝術(shù)，但是作為語言的基礎——詞匯，卻不像藝術(shù)那樣賞心悅目。不斷的記憶與復習，讓詞匯成為很多孩子在學習英語時，最難完全攻克的關卡。本文就來用Python制作一個簡單的英語單詞游戲吧2023-03-03
這篇文章主要介紹了編寫Python CGI腳本的教程,CGI是Python和服務器軟件連接的接口,需要的朋友可以參考下2015-06-06
python微信聊天機器人改進版(定時或觸發(fā)抓取天氣預報、勵志語錄等,向好友推送)
這篇文章主要介紹了python微信聊天機器人改進版，定時或觸發(fā)抓取天氣預報、勵志語錄等，向好友推送 ,本文通過實例代碼給大家介紹的非常詳細，具有一定的參考借鑒價值，需要的朋友可以參考下2019-04-04
這篇文章主要介紹了.img/.hdr格式轉(zhuǎn).nii格式的操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-07-07
python多線程+代理池爬取天天基金網(wǎng)、股票數(shù)據(jù)過程解析
這篇文章主要介紹了python多線程+代理池爬取天天基金網(wǎng)、股票數(shù)據(jù)過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-08-08
Django REST框架創(chuàng)建一個簡單的Api實例講解
在本篇文章里小編給大家整理的是關于Django REST框架創(chuàng)建一個簡單的Api實例講解，有需要的朋友們可以學習下。2019-11-11
Python爬蟲過程解析之多線程獲取小米應用商店數(shù)據(jù)
這篇文章主要介紹了Python爬蟲過程解析之多線程獲取小米應用商店數(shù)據(jù),本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-11-11