溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
什么是線程？
線程（英語：thread）是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以并發多個線程，每條線程并行執行不同的任務。在Unix System V及SunOS中也被稱為輕量進程（lightweight processes），但輕量進程更多指內核線程（kernel thread），而把用戶線程（user thread）稱為線程。
線程是獨立調度和分派的基本單位。線程可以為操作系統內核調度的內核線程，如Win32線程；由用戶進程自行調度的用戶線程，如Linux平臺的POSIX Thread；或者由內核與用戶進程，如Windows 7的線程，進行混合調度。
我們知道，一個線程可以用來執行一個任務，并且該任務的執行是異步的，并不會阻塞后面的代碼。在一個java進程中，包含main方法的類也是在一個線程中執行的。在實際應用中，如果需要處理一個比較耗時的操作，為了不影響程序整體的響應，通常會將這個耗時的操作封裝到一個線程中，異步的執行。但是，線程是怎樣實現任務的異步執行的呢？本文將深入了解Thread類，以期望得出線程執行的秘密。
根據《深入理解JAVA虛擬機》中關于線程的章節，我們得知，在java中一個Thread對應著操作系統中的一個線程。而操作系統的線程是稀缺資源，不能無限制的創建線程，這也就是為什么要使用線程池的原因之一。
我們也知道，在java中要實現一個線程，有兩種方式：
但是不管是哪種方式，最后線程的執行還是要通過調用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相關的常見性的問題：
public static void main(String[] args){
Thread t1 = new Thread();
t1.start();
t1.join();
// 以下代碼會在t1執行完畢后打印
System.out.println("t1 finished");
}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();
}MyRunnable r = new MyRunnable();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
// t1/t2線程操作的都是同一個實例r，所以r中的數據可以實現多線程共享
t1.start();
t2.start();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函數去處理這些任務
最后運行一段時間之后，阻塞隊列中的任務也執行完了，線程池中超過核心線程數的線程會在空閑一段時間內自動回收
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
