java創建的線程
Ⅰ java創建線程的方式有幾種
java創建線程的方式有三種x0dx0a第一種是繼承Thread類 實現方法run() 不可以拋異常 無返回值x0dx0a第二種是實現Runnable介面 實現方法run() 不可以拋異常 無返回值x0dx0a第三種是實現Callable
Ⅱ Java語言：Java多線程怎樣創建
Java提供了線程類Thread來創建多線程的程序。其實，創建線程與創建普通的類的對象的操作是一樣的，而線程就是Thread類或其子類的實例對象。每個Thread對象描述了一個單獨的線程。要產生一個線程，有兩種方法：
需要從Java.lang.Thread類派生一個新的線程類，重載它的run()方法；
實現Runnalbe介面，重載Runnalbe介面中的run()方法。
但，為什麼Java要提供兩種方法來創建線程呢？它們都有哪些區別？相比而言，哪一種方法更好呢？
在Java中，類僅支持單繼承，也就是說，當定義一個新的類的時候，它只能擴展一個外部類.這樣，如果創建自定義線程類的時候是通過擴展 Thread類的方法來實現的，那麼這個自定義類就不能再去擴展其他的類，也就無法實現更加復雜的功能。因此，如果自定義類必
須擴展其他的類，那麼就可以使用實現Runnable介面的方法來定義該類為線程類，這樣就可以避免Java單繼承所帶來的局限性。
還有一點最重要的就是使用實現Runnable介面的方式創建的線程可以處理同一資源，從而實現資源的共享.
（1）通過擴展Thread類來創建多線程
假設一個影院有三個售票口，分別用於向兒童、成人和老人售票。影院為每個窗口放有100張電影票，分別是兒童票、成人票和老人票。三個窗口需要同時賣票，而現在只有一個售票員，這個售票員就相當於一個CPU，三個窗口就相當於三個線程。通過程序來看一看是如
何創建這三個線程的。
public class MutliThreadDemo {
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
m1.start();
m2.start();
m3.start();
}
}
class MutliThread extends Thread{
private int ticket=100;//每個線程都擁有100張票
MutliThread(String name){
super(name);//調用父類帶參數的構造方法
}
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
}
}
}
程序中定義一個線程類，它擴展了Thread類。利用擴展的線程類在MutliThreadDemo類的主方法中創建了三個線程對象，並通過start()方法分別將它們啟動。
從結果可以看到，每個線程分別對應100張電影票，之間並無任何關系，這就說明每個線程之間是平等的，沒有優先順序關系，因此都有機會得到CPU的處理。但是結果顯示這三個線程並不是依次交替執行，而是在三個線程同時被執行的情況下，有的線程被分配時間片的機
會多，票被提前賣完，而有的線程被分配時間片的機會比較少，票遲一些賣完。
可見，利用擴展Thread類創建的多個線程，雖然執行的是相同的代碼，但彼此相互獨立，且各自擁有自己的資源，互不幹擾。
（2）通過實現Runnable介面來創建多線程
public class MutliThreadDemo2 {
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
Thread t1=new Thread(m1);
Thread t2=new Thread(m2);
Thread t3=new Thread(m3);
t1.start();
t2.start();
t3.start();
}
}
class MutliThread implements Runnable{
private int ticket=100;//每個線程都擁有100張票
private String name;
MutliThread(String name){
this.name=name;
}
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+name);
}
}
}
由於這三個線程也是彼此獨立，各自擁有自己的資源，即100張電影票，因此程序輸出的結果和（1）結果大同小異。均是各自線程對自己的100張票進行單獨的處理，互不影響。
可見，只要現實的情況要求保證新建線程彼此相互獨立，各自擁有資源，且互不幹擾，採用哪個方式來創建多線程都是可以的。因為這兩種方式創建的多線程程序能夠實現相同的功能。
由於這三個線程也是彼此獨立，各自擁有自己的資源，即100張電影票，因此程序輸出的結果和例4.2.1的結果大同小異。均是各自線程對自己的100張票進行單獨的處理，互不影響。
可見，只要現實的情況要求保證新建線程彼此相互獨立，各自擁有資源，且互不幹擾，採用哪個方式來創建多線程都是可以的。因為這兩種方式創建的多線程程序能夠實現相同的功能。
（3）通過實現Runnable介面來實現線程間的資源共享
現實中也存在這樣的情況，比如模擬一個火車站的售票系統，假如當日從A地發往B地的火車票只有100張，且允許所有窗口賣這100張票，那麼每一個窗口也相當於一個線程，但是這時和前面的例子不同之處就在於所有線程處理的資源是同一個資源，即100張車票。如果
還用前面的方式來創建線程顯然是無法實現的，這種情況該怎樣處理呢？看下面這個程序，程序代碼如下所示：
public class MutliThreadDemo3 {
public static void main(String [] args){
MutliThread m=new MutliThread();
Thread t1=new Thread(m,"Window 1");
Thread t2=new Thread(m,"Window 2");
Thread t3=new Thread(m,"Window 3");
t1.start();
t2.start();
t3.start();
}
}
class MutliThread implements Runnable{
private int ticket=100;//每個線程都擁有100張票
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
}
}
}
結果正如前面分析的那樣，程序在內存中僅創建了一個資源，而新建的三個線程都是基於訪問這同一資源的，並且由於每個線程上所運行的是相同的代碼，因此它們執行的功能也是相同的。
可見，如果現實問題中要求必須創建多個線程來執行同一任務，而且這多個線程之間還將共享同一個資源，那麼就可以使用實現Runnable介面的方式來創建多線程程序。而這一功能通過擴展Thread類是無法實現的，讀者想想看，為什麼？
實現Runnable介面相對於擴展Thread類來說，具有無可比擬的優勢。這種方式不僅有利於程序的健壯性，使代碼能夠被多個線程共享，而且代碼和數據資源相對獨立，從而特別適合多個具有相同代碼的線程去處理同一資源的情況。這樣一來，線程、代碼和數據資源三者
有效分離，很好地體現了面向對象程序設計的思想。因此，幾乎所有的多線程程序都是通過實現Runnable介面的方式來完成的。
Ⅲ java中怎麼創建線程
Java使用Thread類代表線程，所有的線程對象都必須是Thread類或其子類的實例。Java可以用三種方式來創建線程，如下所示：
1）繼承Thread類創建線程
2）實現Runnable介面創建線程
3）使用Callable和Future創建線程
Ⅳ java創建線程的幾種方式，了解一下
第一種方式：使用Runnable介面創建線程
第二種方式：直接繼承Thread類創建對象
使用Runnable介面創建線程
1.可以將CPU，代碼和數據分開，形成清晰的模型
2.線程體run()方法所在的類可以從其它類中繼承一些有用的屬性和方法
3.有利於保持程序的設計風格一致
直接繼承Thread類創建對象
1.Thread子類無法再從其它類繼承（java語言單繼承）。
2.編寫簡單，run()方法的當前對象就是線程對象，可直接操作。
在實際應用中，幾乎都採取第一種方式
Ⅳ Java並發編程：如何創建線程，進程
在java中如果要創建線程的話，一般有兩種方式：1）繼承Thread類；2）實現Runnable介面。
1.繼承Thread類
繼承Thread類的話，必須重寫run方法，在run方法中定義需要執行的任務。
123456789101112
class MyThread extends Thread{ private static int num = 0; public MyThread(){ num++; } @Override public void run() { System.out.println("主動創建的第"+num+"個線程"); }}
創建好了自己的線程類之後，就可以創建線程對象了，然後通過start()方法去啟動線程。注意，不是調用run()方法啟動線程，run方法中只是定義需要執行的任務，如果調用run方法，即相當於在主線程中執行run方法，跟普通的方法調用沒有任何區別，此時並不會創建一個新的線程來執行定義的任務。public class Test { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); }} class MyThread extends Thread{ private static int num = 0; public MyThread(){ num++; } @Override public void run() { System.out.println("主動創建的第"+num+"個線程"); }}
在上面代碼中，通過調用start()方法，就會創建一個新的線程了。為了分清start()方法調用和run()方法調用的區別，請看下面一個例子：
212223
public class Test { public static void main(String[] args) { System.out.println("主線程ID:"+Thread.currentThread().getId()); MyThread thread1 = new MyThread("thread1"); thread1.start(); MyThread thread2 = new MyThread("thread2"); thread2.run(); }} class MyThread extends Thread{ private String name; public MyThread(String name){ this.name = name; } @Override public void run() { System.out.println("name:"+name+" 子線程ID:"+Thread.currentThread().getId()); }
Ⅵ Java多線程程序設計初步入門
在Java語言產生前 傳統的程序設計語言的程序同一時刻只能單任務操作 效率非常低 例如程序往往在接收數據輸入時發生阻塞 只有等到程序獲得數據後才能繼續運行 隨著Internet的迅猛發展 這種狀況越來越不能讓人們忍受 如果網路接收數據阻塞 後台程序就處於等待狀態而不繼續任何操作 而這種阻塞是經常會碰到的 此時CPU資源被白白的閑置起來 如果在後台程序中能夠同時處理多個任務 該多好啊！應Internet技術而生的Java語言解決了這個問題 多線程程序是Java語言的一個很重要的特點 在一個Java程序中 我們可以同時並行運行多個相對獨立的線程 例如 我們如果創建一個線程來進行數據輸入輸出 而創建另一個線程在後台進行其它的數據處理 如果輸入輸出線程在接收數據時阻塞 而處理數據的線程仍然在運行 多線程程序設計大大提高了程序執行效率和處理能力
線程的創建
我們知道Java是面向對象的程序語言 用Java進行程序設計就是設計和使用類 Java為我們提供了線程類Thread來創建線程 創建線程與創建普通鬧梁的類的對象的操作是一樣的 而線程就是Thread類或其子類的實例對象 下面是一個創建啟動一個線程的語句
Thread thread =new Thread(); file://聲明困彎神一個對象實例 即創建一個線程
Thread run(); file://用Thread類中的run()方法啟動線程
從這個例子 我們可以通過Thread（）構造方法創建一個線程 並啟動該線程 事實上 啟動線程 也就是啟動線程的run（）方法 而Thread類中的run（）方法沒有任何操作語句 所以這個線程沒有任何操作 要使線程實現預定功能 必須定義自己的run（）方法 Java中通常有兩種方式定義run（）方法
通過定義一個Thread類的子類 在該子類中重寫run（）方法 Thread子類的實例對象就是一個線程 顯然 該線程汪虧有我們自己設計的線程體run（）方法 啟動線程就啟動了子類中重寫的run（）方法
通過Runnable介面 在該介面中定義run（）方法的介面 所謂介面跟類非常類似 主要用來實現特殊功能 如復雜關系的多重繼承功能 在此 我們定義一個實現Runnable（） 介面的類 在該類中定義自己的run（）方法 然後以該類的實例對象為參數調用Thread類的構造方法來創建一個線程
線程被實際創建後處於待命狀態 激活（啟動）線程就是啟動線程的run（）方法 這是通過調用線程的start（）方法來實現的
下面一個例子實踐了如何通過上述兩種方法創建線程並啟動它們
// 通過Thread類的子類創建的線程 class thread extends Thread { file://自定義線程的run()方法 public void run() { System out println( Thread is running… ); } } file://通過Runnable介面創建的另外一個線程 class thread implements Runnable { file://自定義線程的run()方法 public void run() { System out println( Thread is running… ); } } file://程序的主類 class Multi_Thread file://聲明主類 { plubic static void mail(String args[]) file://聲明主方法 { thread threadone=new thread (); file://用Thread類的子類創建線程 Thread threado=new Thread(new thread ()); file://用Runnable介面類的對象創建線程 threadone start(); threado start(); file://strat()方法啟動線程 } }
運行該程序就可以看出 線程threadone和threado交替佔用CPU 處於並行運行狀態 可以看出 啟動線程的run()方法是通過調用線程的start()方法來實現的(見上例中主類) 調用start()方法啟動線程的run()方法不同於一般的調用方法 調用一般方法時 必須等到一般方法執行完畢才能夠返回start()方法 而啟動線程的run()方法後 start()告訴系統該線程准備就緒可以啟動run()方法後 就返回start()方法執行調用start()方法語句下面的語句 這時run()方法可能還在運行 這樣 線程的啟動和運行並行進行 實現了多任務操作
線程的優先順序
對於多線程程序 每個線程的重要程度是不盡相同 如多個線程在等待獲得CPU時間時 往往我們需要優先順序高的線程優先搶佔到CPU時間得以執行 又如多個線程交替執行時 優先順序決定了級別高的線程得到CPU的次數多一些且時間多長一些 這樣 高優先順序的線程處理的任務效率就高一些
Java中線程的優先順序從低到高以整數 ~ 表示 共分為 級 設置優先順序是通過調用線程對象的setPriority()方法 如上例中 設置優先順序的語句為
thread threadone=new thread (); file://用Thread類的子類創建線程
Thread threado=new Thread(new thread ()); file://用Runnable介面類的對象創建線程
threadone setPriority( ); file://設置threadone的優先順序
threado setPriority( ); file://設置threado的優先順序
threadone start(); threado start(); file://strat()方法啟動線程
這樣 線程threadone將會優先於線程threado執行 並將佔有更多的CPU時間 該例中 優先順序設置放在線程啟動前 也可以在啟動後進行設置 以滿足不同的優先順序需求
線程的（同步）控制
一個Java程序的多線程之間可以共享數據 當線程以非同步方式訪問共享數據時 有時候是不安全的或者不和邏輯的 比如 同一時刻一個線程在讀取數據 另外一個線程在處理數據 當處理數據的線程沒有等到讀取數據的線程讀取完畢就去處理數據 必然得到錯誤的處理結果 這和我們前面提到的讀取數據和處理數據並行多任務並不矛盾 這兒指的是處理數據的線程不能處理當前還沒有讀取結束的數據 但是可以處理其它的數據
如果我們採用多線程同步控制機制 等到第一個線程讀取完數據 第二個線程才能處理該數據 就會避免錯誤 可見 線程同步是多線程編程的一個相當重要的技術
在講線程的同步控制前我們需要交代如下概念
用Java關鍵字synchonized同步對共享數據操作的方法
在一個對象中 用synchonized聲明的方法為同步方法 Java中有一個同步模型 監視器 負責管理線程對對象中的同步方法的訪問 它的原理是 賦予該對象唯一一把 鑰匙 當多個線程進入對象 只有取得該對象鑰匙的線程才可以訪問同步方法 其它線程在該對象中等待 直到該線程用wait（）方法放棄這把鑰匙 其它等待的線程搶占該鑰匙 搶佔到鑰匙的線程後才可得以執行 而沒有取得鑰匙的線程仍被阻塞在該對象中等待
file://聲明同步的一種方式 將方法聲明同步
class store {public synchonized void store_in(){… }public synchonized void store_out(){ … }}
利用wait（） notify（）及notifyAll（）方法發送消息實現線程間的相互聯系
Java程序中多個線程通過消息來實現互動聯系的 這幾種方法實現了線程間的消息發送 例如定義一個對象的synchonized 方法 同一時刻只能夠有一個線程訪問該對象中的同步方法 其它線程被阻塞 通常可以用notify（）或notifyAll（）方法喚醒其它一個或所有線程 而使用wait（）方法來使該線程處於阻塞狀態 等待其它的線程用notify（）喚醒
一個實際的例子就是生產和銷售 生產單元將產品生產出來放在倉庫中 銷售單元則從倉庫中提走產品 在這個過程中 銷售單元必須在倉庫中有產品時才能提貨 如果倉庫中沒有產品 則銷售單元必須等待
程序中 假如我們定義一個倉庫類store 該類的實例對象就相當於倉庫 在store類中定義兩個成員方法 store_in（） 用來模擬產品製造者往倉庫中添加產品 strore_out（）方法則用來模擬銷售者從倉庫中取走產品 然後定義兩個線程類 customer類 其中的run（）方法通過調用倉庫類中的store_out（）從倉庫中取走產品 模擬銷售者 另外一個線程類procer中的run（）方法通過調用倉庫類中的store_in（）方法向倉庫添加產品 模擬產品製造者 在主類中創建並啟動線程 實現向倉庫中添加產品或取走產品
如果倉庫類中的store_in（） 和store_out（）方法不聲明同步 這就是個一般的多線程 我們知道 一個程序中的多線程是交替執行的 運行也是無序的 這樣 就可能存在這樣的問題
倉庫中沒有產品了 銷售者還在不斷光顧 而且還不停的在 取 產品 這在現實中是不可思義的 在程序中就表現為負值 如果將倉庫類中的stroe_in（）和store_out（）方法聲明同步 如上例所示 就控制了同一時刻只能有一個線程訪問倉庫對象中的同步方法 即一個生產類線程訪問被聲明為同步的store_in（）方法時 其它線程將不能夠訪問對象中的store_out（）同步方法 當然也不能訪問store_in（）方法 必須等到該線程調用wait（）方法放棄鑰匙 其它線程才有機會訪問同步方法
lishixin/Article/program/Java/gj/201311/27301
Ⅶ java中如何啟動一個新的線程
java開啟新線程的三種方法：
方法1：繼承Thread類
1）：定義一個繼承自Java.lang.Thread類的類A.
2）：覆蓋A類Thread類中的run方法。
3）：我們編寫需要在run方法中執行的操作：run方法中的代碼，線程執行體。
4）：在main方法（線程）中，創建一個線程對象並啟動線程。
(1)創建線程類對象:
A類 a = new A類();
(2)調用線程對象的start方法:
a.start();//啟動一個線程
注意：不要調用run方法。如果run方法被稱為對象調用方法，則仍然只有一個線程，並且沒有啟動新線程。
創建啟動線程實例：
(7)java創建的線程擴展閱讀：
啟動新線程的兩種方式對比
繼承方式:
1):從設計上分析，Java中類是單繼承的,如果繼承了Thread了,該類就不能再有其他的直接父類了.
2):從操作上分析,繼承方式更簡單,獲取線程名字也簡單.(操作上,更簡單)
3):從多線程共享同一個資源上分析,繼承方式不能做到.
實現方式:
1):從設計上分析，Java中類可以多實現介面,此時該類還可以繼承其他類,並且還可以實現其他介面，設計更為合理.
2):從操作上分析,實現方式稍微復雜點,獲取線程名字也比較復雜,得使用Thread.currentThread()來獲取當前線程的引用.
3):從多線程共享同一個資源上分析,實現方式可以做到(是否共享同一個資源).
補充：實現方式獲取線程名字：
String name = Thread.currentThread().getName();
Ⅷ java怎麼創建一個線程
Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。可以用如下方式用java中創建一個線程：
Treadthread=newThread();
執行該線程可以調用該線程的start()方法:
thread.start();
編寫線程運行時執行的代碼有兩種方式：一種是創建Thread子類的一個實例並重寫run方法，第二種是創建類的時候實現Runnable介面。接下來我們會具體講解這兩種方法：
創建Thread的子類
創建Thread子類的一個實例並重寫run方法，run方法會在調用start()方法之後被執行。例子如下：
{
publicvoidrun(){
System.out.println("MyThreadrunning");
}
}可以用如下方式創建並運行上述Thread子類
MyThreadmyThread=newMyThread();
myTread.start();
一旦線程啟動後start方法就會立即返回，而不會等待到run方法執行完畢才返回。就好像run方法是在另外一個cpu上執行一樣。當run方法執行後，將會列印出字元串MyThread running。
實現Runnable介面
第二種編寫線程執行代碼的方式是新建一個實現了java.lang.Runnable介面的類的實例，實例中的方法可以被線程調用。下面給出例子：
{
publicvoidrun(){
System.out.println("MyRunnablerunning");
}
}為了使線程能夠執行run()方法，需要在Thread類的構造函數中傳入MyRunnable的實例對象。示例如下：
Threadthread=newThread(newMyRunnable());
thread.start();
當線程運行時，它將會調用實現了Runnable介面的run方法。上例中將會列印出」MyRunnable running」。