1.線程相關(guān)定義
現(xiàn)代操作系統(tǒng)在運行一個程序時瘟栖，會為其創(chuàng)建一個進(jìn)程钧敞。例如蜡豹，啟動一個Java程序，操作系統(tǒng)就會創(chuàng)建一個Java進(jìn)程溉苛。線程是現(xiàn)代操作系統(tǒng)調(diào)度的最小單元镜廉，也叫輕量級進(jìn)程，在一個進(jìn)程里可以創(chuàng)建多個線程愚战，這些線程都擁有各自的計算器娇唯、堆棧和局部變量等屬性齐遵，并且能夠訪問共享的內(nèi)存變量。處理器在這些線程上高速切換塔插，讓使用者感覺到這些線程在同時執(zhí)行梗摇。
2.線程的狀態(tài)
Java線程在運行的生命周期中可能處于下表所示的6種不同的狀態(tài)，在給定的一個時刻想许，線程只能處于其中的一個狀態(tài)伶授。
| 狀態(tài)名稱 | 狀態(tài)說明 |
|---|---|
| NEW | 初始狀態(tài)，線程被構(gòu)建流纹，但是還沒有調(diào)用start()方法 |
| RUNNABLE | 運行狀態(tài)糜烹，Java線程將操作系統(tǒng)中的就緒和運行兩種狀態(tài)籠統(tǒng)地稱作“運行中” |
| WAITING | 等待狀態(tài)，表示線程進(jìn)入等待狀態(tài)漱凝，進(jìn)入該狀態(tài)表示當(dāng)前線程需要等待其他線程做出一些特定動作（通知或中斷） |
| BLOCKED | 阻塞狀態(tài)疮蹦，表示線程阻塞于鎖 |
| TIME_WAITING | 超時等待狀態(tài)，該狀態(tài)不同于WAITING碉哑，它是可以在指定的時間自行返回的 |
| TERMINATED | 終止?fàn)顟B(tài)挚币，表示當(dāng)前線程已經(jīng)執(zhí)行完畢 |
線程狀態(tài)遷移圖：
3.線程的啟動與終止
3.1線程的兩種創(chuàng)建方式
1.繼承Thread
public class ThreadOne extends Thread {
@Override
public void run() {
System.out.println("ThreadOne run.....");
}
}
2.實現(xiàn)Runnable接口
public class RunnableTwo implements Runnable {
@Override
public void run() {
System.out.println("RunnnableTwo run...");
}
}
//運行
public static void main(String[] args) {
ThreadOne threadOne = new ThreadOne();
threadOne.start();
Thread threadTwo = new Thread(new RunnableTwo());
threadTwo.start();
}
3.2線程的中斷
3.2.1什么是線程中斷?
線程中斷即線程運行過程中被其他線程給打斷了，它與 stop 最大的區(qū)別是：stop 是由系統(tǒng)強(qiáng)制終止線程扣典，而線程中斷則是給目標(biāo)線程發(fā)送一個中斷信號妆毕，如果目標(biāo)線程沒有接收線程中斷的信號并結(jié)束線程，線程則不會終止贮尖，具體是否退出或者執(zhí)行其他邏輯由目標(biāo)線程決定笛粘。
3.2.2三個重要的方法
1.java.lang.Thread#interrupt()
給目標(biāo)線程發(fā)送一個中斷信號，線程被打上中斷標(biāo)記湿硝。
2.java.lang.Thread#isInterrupted()
判斷目標(biāo)線程是否處于中斷狀態(tài)薪前，不會清除中斷標(biāo)記。
3.java.lang.Thread#interrupted（靜態(tài)方法）
判斷當(dāng)前線程是否中斷关斜，同時清除中斷標(biāo)記示括。
3.2.3如何安全的終止線程？
可以使用中斷操作或者標(biāo)志位的方式來控制是否需要停止任務(wù)并終止線程痢畜。
下面例子中垛膝，countThread，不斷地進(jìn)行變量累加丁稀，而主線程嘗試進(jìn)行中斷操作吼拥。
public class CountRunner implements Runnable {
private long i;
private volatile boolean flag = true;
@Override
public void run() {
while (flag && !Thread.currentThread().isInterrupted()) {
i++;
}
System.out.println("count =" + i);
}
public void cancel() {
this.flag = false;
}
}
public class Shutdown {
public static void main(String[] args) throws Exception {
CountRunner one = new CountRunner();
Thread countThread = new Thread(one, "countThread");
countThread.start();
//休眠1s，感知中斷而結(jié)束
TimeUnit.SECONDS.sleep(1);
countThread.interrupt();
CountRunner two = new CountRunner();
countThread = new Thread(two, "countThread");
countThread.start();
//休眠1s线衫，感知標(biāo)志位改變結(jié)束
TimeUnit.SECONDS.sleep(1);
two.cancel();
}
}
輸出
count =764735764
count =770902239
4.線程間的通信
4.1等待/通知相關(guān)方法
| 方法名稱 | 描述 |
|---|---|
| wait() | 調(diào)用該方法的線程進(jìn)入waiting狀態(tài)凿可，只有通過其他線程的通知或者中斷才會返回，使用wait后授账，會釋放對象的鎖 |
| wait(long) | 等待指定時間枯跑，ms惨驶，沒有通知就超時返回 |
| wait(long,int) | 對于超時時間更細(xì)粒度的控制，可以達(dá)到納秒 |
| notify() | 通知一個在對象上等待的線程敛助，使其從wait()方法中返回敞咧，而返回的前提是獲取了對象的鎖 |
| notifyAll() | 通知所有等待在該對象上的線程 |
等待/通知機(jī)制，是指一個線程A調(diào)用了對象O的wait()方法進(jìn)入等待狀態(tài)辜腺，而另一個線程B 調(diào)用了對象O的notify()或者notifyAll()方法，線程A收到通知后從對象O的wait()方法返回乍恐，進(jìn)而 執(zhí)行后續(xù)操作评疗。上述兩個線程通過對象O來完成交互，而對象上的wait()和notify/notifyAll()的 關(guān)系就如同開關(guān)信號一樣茵烈，用來完成等待方和通知方之間的交互工作百匆。
例子：
package wainotify;
import java.util.concurrent.TimeUnit;
public class WaitNotify {
private static final Object lock = new Object();
private static boolean flag = false;
public static void main(String[] args) throws Exception {
Thread waitThread = new Thread(new WaitThread());
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new NotifyThread());
notifyThread.start();
}
static class WaitThread implements Runnable {
@Override
public void run() {
synchronized (lock) {
while (!flag) {
try {
System.out.println("WaitThread waiting ......");
lock.wait();
}catch (InterruptedException ex){
}
}
System.out.println("WaitThread start......");
}
System.out.println("WaitThread end");
}
}
static class NotifyThread implements Runnable {
@Override
public void run() {
synchronized (lock) {
flag = true;
System.out.println("NotifyThread notifyAll ......");
lock.notifyAll();
}
System.out.println("NotifyThread end");
}
}
}
交互圖
4.2等待/通知經(jīng)典范式
等待方
1.獲取對象的鎖
2.如果條件不滿足，則調(diào)用對象的wait方法呜投，被通知后仍要檢查
3.執(zhí)行相應(yīng)的邏輯
synchronized(對象){
while(!flag){
object.wait();
}
執(zhí)行相應(yīng)的邏輯
}
通知方
1.獲取對象的鎖
2.改變條件
3.通知所有等待在對象上的線程
synchronized(對象){
flag=true
object.notifyAll()
}
4.3 join
如果一個線程A執(zhí)行了thread.join()語句加匈，其含義是:當(dāng)前線程A等待thread線程終止之后才 從thread.join()返回
例子：多個線程順序執(zhí)行
package join;
public class JoinMain {
public static void main(String[] args) {
Thread previous = Thread.currentThread();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(new Domino(previous), "thread_" + i);
thread.start();
previous = thread;
}
System.out.println(Thread.currentThread().getName() + "..." + "end");
}
static class Domino implements Runnable {
private Thread previous;
Domino(Thread previous) {
this.previous = previous;
}
@Override
public void run() {
try {
previous.join();
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + "..." + "end");
}
}
}
join源碼
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
4.4ThreadLocal
當(dāng)訪問共享變量時，往往需要加鎖來保證數(shù)據(jù)同步仑荐。一種避免使用同步的方式就是不共享數(shù)據(jù)雕拼。如果僅在單線程中訪問數(shù)據(jù)，就不需要同步了粘招。這種技術(shù)稱為線程封閉啥寇。在Java語言中，提供了一些類庫和機(jī)制來維護(hù)線程的封閉性洒扎，例如局部變量和ThreadLocal類辑甜。
package threadlocal;
public class ThreadLocalTest {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Thread thread1 = new Thread(new Local1());
Thread thread2 = new Thread(new local2());
thread1.start();
thread2.start();
}
}
static class Local1 implements Runnable {
@Override
public void run() {
ThreadLocalUtils.set("這是local1");
System.out.println("thread-local1 " + ThreadLocalUtils.get());
}
}
static class local2 implements Runnable {
@Override
public void run() {
ThreadLocalUtils.set("這是local2");
System.out.println("thread-local2 " + ThreadLocalUtils.get());
}
}
}
public class ThreadLocalUtils {
private static final ThreadLocal<String> local = new ThreadLocal<>();
public static void set(String value) {
local.set(value);
}
public static String get() {
return local.get();
}
}
ThreadLocal保存了當(dāng)前線程的副本，多個線程之間互不干擾袍冷，我們看一下ThreadLocal內(nèi)部是如何實現(xiàn)的磷醋。
1.set()方法
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;
}
ThreadLocalMap 是thread的一個成員變量，是和thread相關(guān)聯(lián)的胡诗。
2.TreadLocal是懶加載的邓线。第一次設(shè)置的時候，如果map為null才會創(chuàng)建乃戈，代碼如下：
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
由此可見褂痰，內(nèi)部創(chuàng)建了一個entry數(shù)組，相關(guān)的副本存放在數(shù)組里症虑，且size=1缩歪。
3.entry為ThreadLocalMap的內(nèi)部類
//null的鍵值(entry.get()==null)意味著key不再被引用了，所以entry可以被移除
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
5.結(jié)束
本文參考《Java 并發(fā)編程的藝術(shù)》
