一文深入理解java中的線程

NO IMAGE

一文深入理解java中的線程

深入理解java中的線程

我們知道,一個線程可以用來執行一個任務,並且該任務的執行是異步的,並不會阻塞後面的代碼。在一個java進程中,包含main方法的類也是在一個線程中執行的。在實際應用中,如果需要處理一個比較耗時的操作,為了不影響程序整體的響應,通常會將這個耗時的操作封裝到一個線程中,異步的執行。但是,線程是怎樣實現任務的異步執行的呢?本文將深入瞭解Thread類,以期望得出線程執行的祕密。

根據《深入理解JAVA虛擬機》中關於線程的章節,我們得知,在java中一個Thread對應著操作系統中的一個線程。而操作系統的線程是稀缺資源,不能無限制的創建線程,這也就是為什麼要使用線程池的原因之一。

我們也知道,在java中要實現一個線程,有兩種方式:

  • 繼承Thread類
  • 實現Runnable接口

但是不管是哪種方式,最後線程的執行還是要通過調用Thread的start()方法

讓我們看一下Thread類的重要屬性和方法:

// target就是一個傳遞給Thread等待Thread執行的Runnable對象
/* What will be run. */
private Runnable target;
/* The group of this thread */
private ThreadGroup group;
// 類方法,該方法會在Thread類初始化時,在類的構造器<clinit>中被調用,且只會調用一次,該方法主要的作用是註冊一些本地的方法,以便後期可以使用
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}
// 註冊了以下本地方法:
public static native Thread currentThread();
public static nativevoid yield();
public static native void sleep(long millis) throws InterruptedException;
private native void start0();
private native boolean isInterrupted(boolean ClearInterrupted);
public final native boolean isAlive();
public static native boolean holdsLock(Object obj);
private native static StackTraceElement[][] dumpThreads(Thread[] threads);
private native static Thread[] getThreads();
private native void setPriority0(int newPriority);
private native void stop0(Object o);
private native void suspend0();
private native void resume0();
private native void interrupt0();
private native void setNativeName(String name);

讓我們看看下面這段代碼將輸出什麼內容:

public static class MyThread extends Thread{
@Override
public void run(){
System.out.println("MyThread---1");
}
}
public static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("MyRunnable---1");
}
}
public static void main(String[] args) {
Thread t1 = new MyThread();
Thread t2 = new Thread(new MyRunnable());
t1.start();
t2.start();
System.out.println("MyThread---2");
System.out.println("MyRunnable---2");
}

該代碼的輸出內容是不確定的,可能輸出為:

MyThread---2
MyRunnable---2
MyRunnable---1
MyThread---1

也可能輸出為:

MyThread---1
MyRunnable---1
MyThread---2
MyRunnable---2

但是如果把上述的代碼t1.start(),t2.start()改為:

t1.run();
t2.run();

那麼輸出將變成確定的:

MyThread---1
MyRunnable---1
MyThread---2
MyRunnable---2

為什麼使用start(),輸出的內容是不確定的,而使用run()輸出卻是確定的呢?這就需要從Thread的啟動過程開始瞭解了。 Thread類中start()方法的源代碼如下:

public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();

可以看到,start()方法內部其實調用了一個native的方法start0()。而在Thread類初始化時,執行了一個registerNatives()的方法來註冊本地方法,其中start0方法實際關聯的是JVM_StartThread方法:

{"start0", "()V",(void *)&JVM_StartThread}

在 jvm.cpp 中,有如下代碼段:

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread)){
...
native_thread = new JavaThread(&thread_entry, sz);
...
}

這裡JVMENTRY是一個宏,用來定義JVMStartThread函數,可以看到函數內創建了真正的平臺相關的本地線程,其線程函數是thread_entry,如下:

static void thread_entry(JavaThread* thread, TRAPS) {
HandleMark hm(THREAD);
Handle obj(THREAD, thread->threadObj());
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,obj,KlassHandle(THREAD,SystemDictionary::Thread_klass()),
vmSymbolHandles::run_method_name(),    //調用了run_method_name
vmSymbolHandles::void_method_signature(),THREAD);
}

可以看到調用了vmSymbolHandles::runmethodname方法,而runmethodname是在vmSymbols.hpp 用宏定義的:

class vmSymbolHandles: AllStatic {
...
// 這裡決定了調用的方法名稱是 “run”
template(run_method_name,"run")
...
}

從以上的代碼中可以看出,Thread執行start()方法,首先會創建一個新的操作系統的線程,然後當該操作線程得到CPU時間片時,會執行一個回調方法:run(),這也就證明了通過start()可以創建一個新線程並異步執行線程體,而通過run()只是執行了一個Thread對象的普通方法而已,並不會並行執行,而是串行執行的。

以下附上一些Thread相關的常見性的問題:

Thread的sleep、join、yield

  • 1.sleep
  1. sleep()使當前線程進入停滯狀態(阻塞當前線程),讓出CPU的使用,以留一定時間給其他線程執行
  2. sleep休眠時不會釋放對象的鎖
  • 2.join
    在一個線程A中執行了線程B的join方法,則A會掛起,等待B執行完畢後再執行後續任務
public static void main(String[] args){
Thread t1 = new Thread();
t1.start();
t1.join();
// 以下代碼會在t1執行完畢後打印
System.out.println("t1 finished");
}
  • 3.yield
  1. yield並不意味著退出和暫停,只是,告訴線程調度如果有人需要,可以先拿去,我過會再執行,沒人需要,我繼續執行
  2. 調用yield的時候鎖並沒有被釋放

object的wait、notify、notifyAll

  • 1.wait
  1. wait()方法是Object類裡的方法;當一個線程執行到wait()方法時
  2. 該線程就進入到一個和該對象相關的等待池中,同時失去了對象的鎖,被喚醒時再次獲得鎖
  3. wait()使用notify()或者notifyAll()或者指定睡眠時間來喚醒當前等待池中的線程
  4. wait()必須放在synchronized塊中,否則會報錯”java.lang.IllegalMonitorStateException”
  • 2.notify

wait()和notify()必須操作同一個”對象監視器”

Runnable1 implements Runnable{
public void run(){
synchronized(lock){
// 等待其他線程來喚醒
lock.wait();
System.out.println("Runnable1 has been notified by other thread");
}
}
}
Runnable2 implements Runnable{
public void run(){
synchronized(lock){
System.out.println("Runnable2 will notify other thread who wait for lock");
// 喚醒其他線程            lock.notify();
}
}
}
public static void main(String[] args){
Object lock = new Object();
Thread t1 = new Thread(new Runnable1(lock));
Thread t2 = new Thread(new Runnable2(lock));
t1.start();
t2.start();
}

Thread和Runnable的區別

  • Runnable可以通過Thread的start(實際調用了target的run方法)啟動,而Thread中target的屬性就是一個Runnable
  • Runnable可以實現屬性資源共享,Thread不可以實現資源共享
MyRunnable r = new MyRunnable();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
// t1/t2線程操作的都是同一個實例r,所以r中的數據可以實現多線程共享
t1.start();
t2.start();

線程之間如何進行通信

  • join : 一個線程等待另一個線程執行完畢後再執行
  • wait/notify : 一個線程等待另一個線程喚醒自己所擁有的對象監視器後再執行
  • CountdownLatch : 一個線程等待(countDownLatch.await())其他任意個數的線程執行完畢後(countDownLatch.countDown())再執行
  • CyclicBarrier : 所有線程先各自準備,當所有線程都準備完畢(全部都調用了cyclicBarrier.await())後統一開始執行後續操作
  • Semaphore : 可以控制同時訪問的線程個數,通過acquire()獲取一個許可,如果沒有就等待,而release()釋放一個許可
  • Callable : 子線程將執行結果返回給父線程
FutureTask<Integer> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
Object result = futureTask.get();
  1. CountDownLatch和CyclicBarrier都能夠實現線程之間的等待,只不過它們側重點不同:
  2. CountDownLatch一般用於某個線程A等待若干個其他線程執行完任務之後,它才執行;
  3. CyclicBarrier一般用於一組線程互相等待至某個狀態,然後這一組線程再同時執行;
  4. 另外,CountDownLatch是不能夠重用的,而CyclicBarrier是可以重用的。
  5. Semaphore其實和鎖有點類似,它一般用於控制對某組資源的訪問權限。

線程池的原理

線程池有兩個參數:核心線程數coreNum和最大線程數maxNum

假設初始化一個線程池,核心線程數是5,最大線程數是10,線程池初始化的時候,裡面是沒有線程的

當來了一個任務時,就初始化了一個線程,如果再來一個任務,再初始化了一個線程,連續初始化了5個線程之後,如果第6個任務過來了

這時會把第6個任務放到阻塞隊列中

現在線程池中有了5個線程,如果其中一個線程空閒了,就會從阻塞隊列中獲取第6個任務,進行執行

如果線程池的5個線程都在running狀態,那麼任務就先保存在阻塞隊列中

如果隊列滿了,並且我們設置了最大線程數是10,但線程池中只有5個線程,這時會新建一個線程去執行不能保存到阻塞隊列的任務,此時線程池中有了6個線程

如果線程池中的線程數達到10個了,並且阻塞隊列也滿了,則可以通過自定義的reject函數去處理這些任務

最後運行一段時間之後,阻塞隊列中的任務也執行完了,線程池中超過核心線程數的線程會在空閒一段時間內自動回收

相關文章

🇮🇷蘇萊曼尼遇刺,竟是因為這個….

ES6import/export靜態編譯

ES6系列之箭頭函數全解析

ObjectiveC基礎之四(深入理解Block)