❶ 創建多線程有幾種方法
1、通過繼承Thread類創建線程
(1).首先定義一個類去繼承Thread父類,重寫父類中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。
(2).直接創建一個ThreadTest類的對象,也可以利用多態性,變數聲明為父類的類型。
(3).調用start方法,線程啟動,隱含的調用run()方法。
[java]view plain
{
publicvoidrun(){
for(inti=0;i<=10;i++){
System.out.println(i);
}
}
publicstaticvoidmain(String[]args){
ThreadTestthread1=newThreadTest();
ThreadTestthread2=newThreadTest();
thread1.start();
thread2.start();
}
}
2、通過實現Runnable介面創建線程
(1).定義一個類實現Runnable介面,重寫介面中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。
(2).創建Runnable介面實現類的對象。
(3).創建一個ThreadTest類的對象,需要封裝前面Runnable介面實現類的對象。(介面可以實現多繼承)
(4).調用Thread對象的start()方法,啟動線程
[java]view plain
{
@Override
publicvoidrun(){
for(inti=0;i<=10;i++){
System.out.println(i);
}
}
publicstaticvoidmain(String[]args){
ThreadTestthreadTest=newThreadTest();
Threadtheard=newThread(threadTest);
theard.start();
}
}
3.通過Callable和Future創建線程
(1)創建Callable介面的實現類,並實現call()方法,該call()方法將作為線程執行體,並且有返回值。
(2)創建Callable實現類的實例,使用FutureTask類來包裝Callable對象,該FutureTask對象封裝了該Callable對象的call()方法的返回值。
(3)使用FutureTask對象作為Thread對象的target創建並啟動新線程。
(4)調用FutureTask對象的get()方法來獲得子線程執行結束後的返回值
[java]view plain
<Integer>{
@Override
publicIntegercall()throwsException{
intcount=0;
for(inti=0;i<=10;i++){
count=count+i;
}
returncount;
}
publicstaticvoidmain(String[]args)throwsInterruptedException,ExecutionException{
ThreadTesttest=newThreadTest();
FutureTask<Integer>thread=newFutureTask<>(test);
newThread(thread,"有返回值的線程").start();
System.out.println(thread.get());
}
}
使用實現Runnable介面方式創建線程可以共享同一個目標對象(TreadDemo1 tt=new TreadDemo1();),實現了多個相同線程處理同一份資源。
然後再看一段來自JDK的解釋:
TheRunnableinterface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments calledrun.
This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example,Runnableis implemented by classThread. Being active simply means that a thread has been started and has not yet been stopped.
In addition,Runnableprovides the means for a class to be active while not subclassingThread. A class that implementsRunnablecan run without subclassingThreadby instantiating aThreadinstance and passing itself in as the target. In most cases, theRunnableinterface should be used if you are only planning to override therun()method and no otherThreadmethods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.
採用實現Runnable、Callable介面的方式創見多線程時,優勢是:
線程類只是實現了Runnable介面或Callable介面,還可以繼承其他類。
在這種方式下,多個線程可以共享同一個target對象,所以非常適合多個相同線程來處理同一份資源的情況,從而可以將CPU、代碼和數據分開,形成清晰的模型,較好地體現了面向對象的思想。
劣勢是:
採用繼承Thread類方式:
(1)優點:編寫簡單,如果需要訪問當前線程,無需使用Thread.currentThread()方法,直接使用this,即可獲得當前線程。
(2)缺點:因為線程類已經繼承了Thread類,所以不能再繼承其他的父類。
採用實現Runnable介面方式:
(1)優點:線程類只是實現了Runable介面,還可以繼承其他的類。在這種方式下,可以多個線程共享同一個目標對象,所以非常適合多個相同線程來處理同一份資源的情況,從而可以將CPU代碼和數據分開,形成清晰的模型,較好地體現了面向對象的思想。
(2)缺點:編程稍微復雜,如果需要訪問當前線程,必須使用Thread.currentThread()方法。
❷ 多線程的定義是什麼
線程是一組指令的集合,或者是程序的特殊段,它可以在程序里獨立執行。也可以把它理解為代碼運行的上下文。所以線程基本上是輕量級的進程,它負責在單個程序里執行多任務。通常由操作系統負責多個線程的調度和執行。
多線程是這樣一種機制,它允許在程序中並發執行多個指令流,每個指令流都稱為一個線程,彼此間互相獨立。線程又稱為輕量級進程,它和進程一樣擁有獨立的執行控制,由操作系統負責調度。
多線程是多任務的特殊形式。通常,有兩種類型的多任務:基於進程和基於線程的多任務。進程本質上是正在執行的程序。因此,基於進程的多任務就是允許您的計算機同時運行兩個或者更多程序的特性。例如,基於進程的多任務允許您在使用電子製表軟體或者瀏覽Internet的同時運行文字處理程序。在基於進程的多任務中,程序是調度程序可以分派的最小代碼單元。
多線程是為了使得多個線程並行的工作以完成多項任務,以提高系統的效率。線程是在同一時間需要完成多項任務的時候被實現的。
使用線程的好處有以下幾點:
·使用線程可以把占據長時間的程序中的任務放到後台去處理
·用戶界面可以更加吸引人,這樣比如用戶點擊了一個按鈕去觸發某些事件的處理,可以彈出一個進度條來顯示處理的進度
·程序的運行速度可能加快
·在一些等待的任務實現上如用戶輸入、文件讀寫和網路收發數據等,線程就比較游泳了。在這種情況下我們可以釋放一些珍貴的資源如內存佔用等等。
還有其他很多使用多線程的好處,這里就不一一說明了。
多線程應用
我們以客戶/伺服器應用模式中如何進行伺服器程序設計為例,來說明多線程技術的應用。該程序是在DECnet-VAX網路郵箱上實現的。對於TCP/IP,除了改用捆綁的套接字(socket)來代替DECnet中的網路郵箱以監視客戶的服務請求外,其他方面基本上是一樣的。
為了簡化說明,假定該服務程序只提供2類功能,分別由函數funcl( )和func2( )來實現。客戶在請求服務時要指明功能號1或2。另外限制需要同時提供服務的客戶數目。
多線程程序的基本設計思想是,為請求服務的每個客戶建立1個線程,專門為該客戶提供服務。限制客戶數目就是限制同時存在的線程數目。這些動態建立的線程對象存放在數組中。通過查找該數組是否有空槽,來決定是否達到最大數目。同時利用該數組來管理這些動態存在的線程及相應的網路鏈路。整個程序由1個主程序和提供2類服務的2個子程序組成。主程序(主控線程)在完成初始化操作後,開始循環讀取郵箱中的網路控制信息;在接收到連接請求信息後,主控線程就建立1個新線程,並指定相應的函數作為執行代碼;如果客戶要斷開連接,則主控線程查找到相應的服務線程號,釋放該服務線程使用的網路鏈路,並刪除此線程。
❸ java中什麼叫做線程什麼叫多線程多線程的特點是什麼
線程的概念:Thread 每個正在系統上運行的程序都是一個進程。每個進程包含一到多個線程。進程也可能是整個程序或者是部分程序的動態執行。
多線程的概念: 多線程是為了同步完成多項任務,不是為了提高運行效率,而是為了提高資源使用效率來提高系統的效率。
多線程的特點:使用線程可以把占據長時間的程序中的任務放到後台去處理
用戶界面可以更加吸引人,這樣比如用戶點擊了一個按鈕去觸發某些事件的處理,可以彈出一個進度條來顯示處理的進度 。
程序的運行速度可能加快 ·在一些等待的任務實現上如用戶輸入、文件讀寫和網路收發數據等,線程就比較有用了。
在這種情況下我們可以釋放一些珍貴的資源如內存佔用等等。
❹ 多線程是什麼
1.多線程的概念?
說起多線程,那麼就不得不說什麼是線程,而說起線程,又不得不說什麼是進程。
進程(Process)是計算機中的程序關於某數據集合上的一次運行活動,是系統進行資源分配和調度的基本單位,是操作系統結構的基礎。在早期面向進程設計的計算機結構中,進程是程序的基本執行實體;在當代面向線程設計的計算機結構中,進程是線程的容器。程序是指令、數據及其組織形式的描述,進程是程序的實體。
進程可以簡單的理解為一個可以獨立運行的程序單位。它是線程的集合,進程就是有一個或多個線程構成的,每一個線程都是進程中的一條執行路徑。
那麼多線程就很容易理解:多線程就是指一個進程中同時有多個執行路徑(線程)正在執行。
為什麼要使用多線程?
1.在一個程序中,有很多的操作是非常耗時的,如資料庫讀寫操作,IO操作等,如果使用單線程,那麼程序就必須等待這些操作執行完成之後才能執行其他操作。使用多線程,可以在將耗時任務放在後台繼續執行的同時,同時執行其他操作。
2.可以提高程序的效率。
3.在一些等待的任務上,如用戶輸入,文件讀取等,多線程就非常有用了。
缺點:
1.使用太多線程,是很耗系統資源,因為線程需要開辟內存。更多線程需要更多內存。
2.影響系統性能,因為操作系統需要在線程之間來回切換。
3.需要考慮線程操作對程序的影響,如線程掛起,中止等操作對程序的影響。
4.線程使用不當會發生很多問題。
總結:多線程是非同步的,但這不代表多線程真的是幾個線程是在同時進行,實際上是系統不斷地在各個線程之間來回的切換(因為系統切換的速度非常的快,所以給我們在同時運行的錯覺)。
2.多線程與高並發的聯系。
高並發:高並發指的是一種系統運行過程中遇到的一種「短時間內遇到大量操作請求」的情況,主要發生在web系統集中大量訪問或者socket埠集中性收到大量請求(例如:12306的搶票情況;天貓雙十一活動)。該情況的發生會導致系統在這段時間內執行大量操作,例如對資源的請求,資料庫的操作等。如果高並發處理不好,不僅僅降低了用戶的體驗度(請求響應時間過長),同時可能導致系統宕機,嚴重的甚至導致OOM異常,系統停止工作等。如果要想系統能夠適應高並發狀態,則需要從各個方面進行系統優化,包括,硬體、網路、系統架構、開發語言的選取、數據結構的運用、演算法優化、資料庫優化……。
而多線程只是在同/非同步角度上解決高並發問題的其中的一個方法手段,是在同一時刻利用計算機閑置資源的一種方式。
多線程在高並發問題中的作用就是充分利用計算機資源,使計算機的資源在每一時刻都能達到最大的利用率,不至於浪費計算機資源使其閑置。
3.線程的創建,停止,常用方法介紹。
1.線程的創建:
線程創建主要有2種方式,一種是繼承Thread類,重寫run方法即可;(Thread類實現了Runable介面)
另一種則是實現Runable介面,也需要重寫run方法。
線程的啟動,調用start()方法即可。 我們也可以直接使用線程對象的run方法,不過直接使用,run方法就只是一個普通的方法了。
其他的還有: 通過匿名內部類的方法創建;實現Callable介面。。。。。
2.線程常用方法:
currentThread()方法:該方法返回當前線程的信息 .getName()可以返回線程名稱。
isAlive()方法:該方法判斷當前線程是否處於活動狀態。
sleep()方法:該方法是讓「當前正在執行的線程「休眠指定的時間,正在執行的線程是指this.currentThread()返回的線程。
getId()方法:該方法是獲取線程的唯一標識。
3.線程的停止:
在java中,停止線程並不簡單,不想for。。break那樣說停就停,需要一定的技巧。
線程的停止有3種方法:
1.線程正常終止,即run()方法運行結束正常停止。
2.使用interrupt方法中斷線程。
3.使用stop方法暴力停止線程。
interrupt方法中斷線程介紹:
interrupt方法其實並不是直接中斷線程,只是給線程添加一個中斷標志。
判斷線程是否是停止狀態:
this.interrupted(); 判斷當前線程是否已經中斷。(判斷的是這個方法所在的代碼對應的線程,而不是調用對象對應的線程)
this.isInterrupted(); 判斷線程是否已經中斷。(誰調用,判斷誰)
註:.interrupted()與isInterrupted()的區別:
interrupted()方法判斷的是所在代碼對應的線程是否中斷,而後者判斷的是調用對象對應的線程是否停止
前者執行後有清除狀態的功能(如連續調用兩次時,第一次返回true,則第二次會返回false)
後者沒有清除狀態的功能(兩次返回都為true)
真正停止線程的方法:
異常法:
在run方法中 使用 this.interrupted();判斷線程終止狀態,如果為true則 throw new interruptedException()然後捕獲該異常即可停止線程。
return停止線程:
在run方法中 使用 this.interrupted();判斷線程終止狀態,如果為true則return停止線程。 (建議使用異常法停止線程,因為還可以在catch中使線程向上拋,讓線程停止的事件得以傳播)。
暴力法:
使用stop()方法強行停止線程(強烈不建議使用,會造成很多不可預估的後果,已經被標記為過時)
(使用stop方法會拋出 java.lang.ThreadDeath 異常,並且stop方法會釋放鎖,很容易造成數據不一致)
註:在休眠中停止線程:
在sleep狀態下停止線程 會報異常,並且會清除線程狀態值為false;
先停止後sleep,同樣會報異常 sleep interrupted;
4.守護線程。
❺ 多線程的定義
在計算機編程中,一個基本的概念就是同時對多個任務加以控制。許多程序設計問題都要求程序能夠停下手
頭的工作,改為處理其他一些問題,再返回主進程。可以通過多種途徑達到這個目的。最開始的時候,那些掌握機器低級語言的程序員編寫一些「中斷服務常式」,主進程的暫停是通過硬體級的中斷實現的。盡管這是一種有用的方法,但編出的程序很難移植,由此造成了另一類的代價高昂問題。中斷對那些實時性很強的任務來說是很有必要的。但對於其他許多問題,只要求將問題劃分進入獨立運行的程序片斷中,使整個程序能更迅速地響應用戶的請求。
最開始,線程只是用於分配單個處理器的處理時間的一種工具。但假如操作系統本身支持多個處理器,那麼每個線程都可分配給一個不同的處理器,真正進入「並行運算」狀態。從程序設計語言的角度看,多線程操作最有價值的特性之一就是程序員不必關心到底使用了多少個處理器。程序在邏輯意義上被分割為數個線程;假如機器本身安裝了多個處理器,那麼程序會運行得更快,毋需作出任何特殊的調校。根據前面的論述,大家可能感覺線程處理非常簡單。但必須注意一個問題:共享資源!如果有多個線程同時運行,而且它們試圖訪問相同的資源,就會遇到一個問題。舉個例子來說,兩個線程不能將信息同時發送給一台列印機。為解決這個問題,對那些可共享的資源來說(比如列印機),它們在使用期間必須進入鎖定狀態。所以一個線程可將資源鎖定,在完成了它的任務後,再解開(釋放)這個鎖,使其他線程可以接著使用同樣的資源。
多線程是為了同步完成多項任務,不是為了提高運行效率,而是為了提高資源使用效率來提高系統的效率。線程是在同一時間需要完成多項任務的時候實現的。
最簡單的比喻多線程就像火車的每一節車廂,而進程則是火車。車廂離開火車是無法跑動的,同理火車也不可能只有一節車廂。多線程的出現就是為了提高效率。同時它的出現也帶來了一些問題。
❻ 什麼是JAVA的多線程
一、 什麼是多線程:
我們現在所使用操作系統都是多任務操作系統(早期使用的DOS操作系統為單任務操作系統),多任務操作指在同一時刻可以同時做多件事(可以同時執行多個程序)。
多進程:每個程序都是一個進程,在操作系統中可以同時執行多個程序,多進程的目的是為了有效的使用CPU資源,每開一個進程系統要為該進程分配相關的系統資源(內存資源)
多線程:線程是進程內部比進程更小的執行單元(執行流|程序片段),每個線程完成一個任務,每個進程內部包含了多個線程每個線程做自己的事情,在進程中的所有線程共享該進程的資源;
主線程:在進程中至少存在一個主線程,其他子線程都由主線程開啟,主線程不一定在其他線程結束後結束,有可能在其他線程結束前結束。Java中的主線程是main線程,是Java的main函數;
二、 Java中實現多線程的方式:
繼承Thread類來實現多線程:
當我們自定義的類繼承Thread類後,該類就為一個線程類,該類為一個獨立的執行單元,線程代碼必須編寫在run()方法中,run方法是由Thread類定義,我們自己寫的線程類必須重寫run方法。
run方法中定義的代碼為線程代碼,但run方法不能直接調用,如果直接調用並沒有開啟新的線程而是將run方法交給調用的線程執行
要開啟新的線程需要調用Thread類的start()方法,該方法自動開啟一個新的線程並自動執行run方法中的內容
java多線程的啟動順序不一定是線程執行的順序,各個線程之間是搶佔CPU資源執行的,所有有可能出現與啟動順序不一致的情況。
CPU的調用策略:
如何使用CPU資源是由操作系統來決定的,但操作系統只能決定CPU的使用策略不能控制實際獲得CPU執行權的程序。
線程執行有兩種方式:
1.搶占式:
目前PC機中使用最多的一種方式,線程搶佔CPU的執行權,當一個線程搶到CPU的資源後並不是一直執行到此線程執行結束,而是執行一個時間片後讓出CPU資源,此時同其他線程再次搶佔CPU資源獲得執行權。
2.輪循式;
每個線程執行固定的時間片後讓出CPU資源,以此循環執行每個線程執行相同的時間片後讓出CPU資源交給下一個線程執行。
希望對您有所幫助!~
❼ java中如何定義和使用多線程 求例子
有兩種,我用了最簡單的一種,繼承Thread類。模擬迅雷的多線程下載,當你選擇下載第一個任務時提示下載需要5秒鍾,這時你可以選擇同時下載第二個任務。我建了兩個類。
第一個類:
public class Multithread extends Thread {
public void run(){
System.out.println("正在下載請等待5秒鍾");
try {
Multithread.sleep(5000);
System.out.println(getName()+"下載完成");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
第二個是測試類:
import java.util.Scanner;
public class Multithreadtest {
public static void main(String[] args) {
System.out.println("1.下載片段a"+"\n2.下載片段b"+"\n3.退出");
Scanner input=new Scanner(System.in);
int choose=0;
while(choose!=3){
System.out.println("請輸入你的選擇");
choose=input.nextInt();
switch(choose){
case 1: Multithread a=new Multithread();
a.start();
break;
case 2: Multithread b=new Multithread();
b.start();
break;
default :
break;
}
}
System.out.println("程序結束");
}
}
❽ 在Java 中多線程的實現方法有哪些,如何使用
Java多線程的創建及啟動
Java中線程的創建常見有如三種基本形式
1.繼承Thread類,重寫該類的run()方法。
復制代碼
1 class MyThread extends Thread {
2
3 private int i = 0;
4
5 @Override
6 public void run() {
7 for (i = 0; i < 100; i++) {
8 System.out.println(Thread.currentThread().getName() + " " + i);
9 }
10 }
11 }
復制代碼
復制代碼
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Thread myThread1 = new MyThread(); // 創建一個新的線程 myThread1 此線程進入新建狀態
8 Thread myThread2 = new MyThread(); // 創建一個新的線程 myThread2 此線程進入新建狀態
9 myThread1.start(); // 調用start()方法使得線程進入就緒狀態
10 myThread2.start(); // 調用start()方法使得線程進入就緒狀態
11 }
12 }
13 }
14 }
復制代碼
如上所示,繼承Thread類,通過重寫run()方法定義了一個新的線程類MyThread,其中run()方法的方法體代表了線程需要完成的任務,稱之為線程執行體。當創建此線程類對象時一個新的線程得以創建,並進入到線程新建狀態。通過調用線程對象引用的start()方法,使得該線程進入到就緒狀態,此時此線程並不一定會馬上得以執行,這取決於CPU調度時機。
2.實現Runnable介面,並重寫該介面的run()方法,該run()方法同樣是線程執行體,創建Runnable實現類的實例,並以此實例作為Thread類的target來創建Thread對象,該Thread對象才是真正的線程對象。
復制代碼
1 class MyRunnable implements Runnable {
2 private int i = 0;
3
4 @Override
5 public void run() {
6 for (i = 0; i < 100; i++) {
7 System.out.println(Thread.currentThread().getName() + " " + i);
8 }
9 }
10 }
復制代碼
復制代碼
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Runnable myRunnable = new MyRunnable(); // 創建一個Runnable實現類的對象
8 Thread thread1 = new Thread(myRunnable); // 將myRunnable作為Thread target創建新的線程
9 Thread thread2 = new Thread(myRunnable);
10 thread1.start(); // 調用start()方法使得線程進入就緒狀態
11 thread2.start();
12 }
13 }
14 }
15 }
復制代碼
相信以上兩種創建新線程的方式大家都很熟悉了,那麼Thread和Runnable之間到底是什麼關系呢?我們首先來看一下下面這個例子。
復制代碼
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Runnable myRunnable = new MyRunnable();
8 Thread thread = new MyThread(myRunnable);
9 thread.start();
10 }
11 }
12 }
13 }
14
15 class MyRunnable implements Runnable {
16 private int i = 0;
17
18 @Override
19 public void run() {
20 System.out.println("in MyRunnable run");
21 for (i = 0; i < 100; i++) {
22 System.out.println(Thread.currentThread().getName() + " " + i);
23 }
24 }
25 }
26
27 class MyThread extends Thread {
28
29 private int i = 0;
30
31 public MyThread(Runnable runnable){
32 super(runnable);
33 }
34
35 @Override
36 public void run() {
37 System.out.println("in MyThread run");
38 for (i = 0; i < 100; i++) {
39 System.out.println(Thread.currentThread().getName() + " " + i);
40 }
41 }
42 }
復制代碼
同樣的,與實現Runnable介面創建線程方式相似,不同的地方在於
1 Thread thread = new MyThread(myRunnable);
那麼這種方式可以順利創建出一個新的線程么?答案是肯定的。至於此時的線程執行體到底是MyRunnable介面中的run()方法還是MyThread類中的run()方法呢?通過輸出我們知道線程執行體是MyThread類中的run()方法。其實原因很簡單,因為Thread類本身也是實現了Runnable介面,而run()方法最先是在Runnable介面中定義的方法。
1 public interface Runnable {
2
3 public abstract void run();
4
5 }
我們看一下Thread類中對Runnable介面中run()方法的實現:
復制代碼
@Override
public void run() {
if (target != null) {
target.run();
}
}
復制代碼
也就是說,當執行到Thread類中的run()方法時,會首先判斷target是否存在,存在則執行target中的run()方法,也就是實現了Runnable介面並重寫了run()方法的類中的run()方法。但是上述給到的列子中,由於多態的存在,根本就沒有執行到Thread類中的run()方法,而是直接先執行了運行時類型即MyThread類中的run()方法。
3.使用Callable和Future介面創建線程。具體是創建Callable介面的實現類,並實現clall()方法。並使用FutureTask類來包裝Callable實現類的對象,且以此FutureTask對象作為Thread對象的target來創建線程。
看著好像有點復雜,直接來看一個例子就清晰了。
復制代碼
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4
5 Callable<Integer> myCallable = new MyCallable(); // 創建MyCallable對象
6 FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask來包裝MyCallable對象
7
8 for (int i = 0; i < 100; i++) {
9 System.out.println(Thread.currentThread().getName() + " " + i);
10 if (i == 30) {
11 Thread thread = new Thread(ft); //FutureTask對象作為Thread對象的target創建新的線程
12 thread.start(); //線程進入到就緒狀態
13 }
14 }
15
16 System.out.println("主線程for循環執行完畢..");
17
18 try {
19 int sum = ft.get(); //取得新創建的新線程中的call()方法返回的結果
20 System.out.println("sum = " + sum);
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 } catch (ExecutionException e) {
24 e.printStackTrace();
25 }
26
27 }
28 }
29
30
31 class MyCallable implements Callable<Integer> {
32 private int i = 0;
33
34 // 與run()方法不同的是,call()方法具有返回值
35 @Override
36 public Integer call() {
37 int sum = 0;
38 for (; i < 100; i++) {
39 System.out.println(Thread.currentThread().getName() + " " + i);
40 sum += i;
41 }
42 return sum;
43 }
44
45 }
復制代碼
首先,我們發現,在實現Callable介面中,此時不再是run()方法了,而是call()方法,此call()方法作為線程執行體,同時還具有返回值!在創建新的線程時,是通過FutureTask來包裝MyCallable對象,同時作為了Thread對象的target。那麼看下FutureTask類的定義:
1 public class FutureTask<V> implements RunnableFuture<V> {
2
3 //....
4
5 }
1 public interface RunnableFuture<V> extends Runnable, Future<V> {
2
3 void run();
4
5 }
於是,我們發現FutureTask類實際上是同時實現了Runnable和Future介面,由此才使得其具有Future和Runnable雙重特性。通過Runnable特性,可以作為Thread對象的target,而Future特性,使得其可以取得新創建線程中的call()方法的返回值。
執行下此程序,我們發現sum = 4950永遠都是最後輸出的。而「主線程for循環執行完畢..」則很可能是在子線程循環中間輸出。由CPU的線程調度機制,我們知道,「主線程for循環執行完畢..」的輸出時機是沒有任何問題的,那麼為什麼sum =4950會永遠最後輸出呢?
原因在於通過ft.get()方法獲取子線程call()方法的返回值時,當子線程此方法還未執行完畢,ft.get()方法會一直阻塞,直到call()方法執行完畢才能取到返回值。
上述主要講解了三種常見的線程創建方式,對於線程的啟動而言,都是調用線程對象的start()方法,需要特別注意的是:不能對同一線程對象兩次調用start()方法。
你好,本題已解答,如果滿意
請點右下角「採納答案」。