java多線程thread

❶ 如何在java 中實現多線程

1、繼承Thread類創建線程
Thread類本質上是實現了Runnable介面的一個實例，代表一個線程的實例。啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：
復制代碼

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

❷ Java中如何用Thread類實現多線程

定義類實現Thread或實現Runnable介面。示例代碼如下：

importjava.util.Random;

publicclassMultiThread{

publicstaticvoidmain(Stringargs[])throwsInterruptedException{

System.out.println("使用繼承Thread的方式實現");
for(inti=0;i<10;i++){
MyThreadt=newMyThread("thread_"+i);
t.start();
}

Thread.sleep(1000);
System.out.println("使用實現Runnable介面的方式實現");
for(inti=10;i<20;i++){
MyThread2t=newMyThread2("thread_"+i);
newThread(t).start();
}
}
}

classMyThreadextendsThread{
privateStringthreadName;

publicMyThread(StringthreadName){
this.threadName=threadName;
}

@Override
publicvoidrun(){
longsleep=newRandom().nextInt(100)+100;
try{
//隨機延遲一段時間
Thread.sleep(sleep);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(threadName+"開始執行...");
}
}

{

privateStringthreadName;

publicMyThread2(StringthreadName){
this.threadName=threadName;
}

@Override
publicvoidrun(){
longsleep=newRandom().nextInt(100)+100;
try{
//隨機延遲一段時間
Thread.sleep(sleep);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(threadName+"開始執行...");
}
}

❸ java，線程Thread(Runnable target)

你的理解很正確，只要是實現了Runnable介面的類都可以傳進去。
這個參數可以是API中已經有的，也可以是自己寫的。
常用的創建線程的方法有兩種，第一種就是繼承Thread類，直接new
出來就可以，Thread類本身也實現了Runnable介面。
第二種方法就是實現Runnable介面裡面的run方法。
語法正如你的代碼一樣

❹ java 如何實現多線程

線程間的通信方式
同步
這里講的同步是指多個線程通過synchronized關鍵字這種方式來實現線程間的通信。
參考示例：
public class MyObject {
synchronized public void methodA() {
//do something....
}
synchronized public void methodB() {
//do some other thing
}
}
public class ThreadA extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodA();
}
}
public class ThreadB extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
//線程A與線程B 持有的是同一個對象:object
ThreadA a = new ThreadA(object);
ThreadB b = new ThreadB(object);
a.start();
b.start();
}
}
由於線程A和線程B持有同一個MyObject類的對象object，盡管這兩個線程需要調用不同的方法，但是它們是同步執行的，比如：線程B需要等待線程A執行完了methodA()方法之後，它才能執行methodB()方法。這樣，線程A和線程B就實現了 通信。
這種方式，本質上就是「共享內存」式的通信。多個線程需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。

❺ java thread 是真的多線程嗎

雙核cpu你可以理解為兩塊cpu,4核、8核等以此類推，就單個cpu而言某個時間點只能是一個線程在運行， 所謂的多線程是通過調度獲取cpu的時間片實現的 其實就相當於 cpu是一個人 多線程是幾件事

❻ java線程Thread和Runnable的區別

JAVA多線程實現方式：繼承Thread類、實現Runnable介面1、繼承Thread類實現多線程繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable介面的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extendThread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法2、實現Runnable介面方式實現多線程如果自己的類已經extends另一個類，就無法直接extendsThread，此時，必須實現一個Runnable介面

❼ java 多線程 繼承Thread和實現Runnable的區別

Java中線程的創建有兩種方式：

1、 通過繼承Thread類，重寫Thread的run()方法，將線程運行的邏輯放在其中

2、 通過實現Runnable介面，實例化Thread類

Runnable
介面只有一個方法 run()，我們聲明自己的類實現 Runnable
介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對線程的支持，我們還必須創建
Thread 類的實例，這一點通過 Thread 類的構造函數public Thread(Runnable target);來實現。

3、繼承Thread實現的模式是 定義多個線程,各自完成各自的任務.

4、實現Runnable實現的模式是 定義多個線程,實現一個任務.

總結：一個是多個線程分別完成自己的任務，一個是多個線程共同完成一個任務。其實，在實現一個任務用多個線程來做也可以用繼承Thread類來實現，只是比較麻煩，一般我們用實現Runnable介面來實現。

❽ JAVA多線程有哪幾種實現方式

JAVA多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

1、繼承Thread類實現多線程
繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable介面的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：

[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 在合適的地方啟動線程如下：



[java]view plain

• MyThreadmyThread1=newMyThread();

• MyThreadmyThread2=newMyThread();

• myThread1.start();

• myThread2.start();



• 2、實現Runnable介面方式實現多線程


• 如果自己的類已經extends另一個類，就無法直接extends Thread，此時，必須實現一個Runnable介面，如下：



[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 為了啟動MyThread，需要首先實例化一個Thread，並傳入自己的MyThread實例：



[java]view plain

• MyThreadmyThread=newMyThread();

• Threadthread=newThread(myThread);

• thread.start();

• 事實上，當傳入一個Runnable target參數給Thread後，Thread的run()方法就會調用target.run()，參考JDK源代碼：



[java]view plain

• publicvoidrun(){

• if(target!=null){

• target.run();

• }

• }



• 3、使用ExecutorService、Callable、Future實現有返回結果的多線程


• ExecutorService、Callable、Future這個對象實際上都是屬於Executor框架中的功能類。想要詳細了解Executor框架的可以訪問http://www.javaeye.com/topic/366591 ，這裡面對該框架做了很詳細的解釋。返回結果的線程是在JDK1.5中引入的新特徵，確實很實用，有了這種特徵我就不需要再為了得到返回值而大費周折了，而且即便實現了也可能漏洞百出。


• 可返回值的任務必須實現Callable介面，類似的，無返回值的任務必須Runnable介面。執行Callable任務後，可以獲取一個Future的對象，在該對象上調用get就可以獲取到Callable任務返回的Object了，再結合線程池介面ExecutorService就可以實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5下驗證過沒問題可以直接使用。

❾ 在Java 中多線程的實現方法有哪些，如何使用

1、 認識Thread和Runnable

Java中實現多線程有兩種途徑：繼承Thread類或者實現Runnable介面。Runnable是介面，建議用介面的方式生成線程，因為介面可以實現多繼承，況且Runnable只有一個run方法，很適合繼承。在使用Thread的時候只需繼承Thread，並且new一個實例出來，調用start()方法即可以啟動一個線程。

Thread Test = new Thread();

Test.start();

在使用Runnable的時候需要先new一個實現Runnable的實例，之後啟動Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

總結：Thread和Runnable是實現java多線程的2種方式，runable是介面，thread是類，建議使用runable實現java多線程，不管如何，最終都需要通過thread.start()來使線程處於可運行狀態。

2、 認識Thread的start和run

1） start：

用start方法來啟動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。通過調用Thread類的start()方法來啟動一個線程，這時此線程處於就緒（可運行）狀態，並沒有運行，一旦得到spu時間片，就開始執行run()方法，這里方法run()稱為線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。

2） run：

run()方法只是類的一個普通方法而已，如果直接調用Run方法，程序中依然只有主線程這一個線程，其程序執行路徑還是只有一條，還是要順序執行，還是要等待run方法體執行完畢後才可繼續執行下面的代碼，這樣就沒有達到寫線程的目的。

總結：調用start方法方可啟動線程，而run方法只是thread的一個普通方法調用，還是在主線程里執行。

3、 線程狀態說明

線程狀態從大的方面來說，可歸結為：初始狀態、可運行狀態、不可運行狀態和消亡狀態，具體可細分為上圖所示7個狀態，說明如下：

1） 線程的實現有兩種方式，一是繼承Thread類，二是實現Runnable介面，但不管怎樣，當我們new了thread實例後，線程就進入了初始狀態；

2） 當該對象調用了start()方法，就進入可運行狀態；

3） 進入可運行狀態後，當該對象被操作系統選中，獲得CPU時間片就會進入運行狀態；

4） 進入運行狀態後case就比較多，大致有如下情形：

·run()方法或main()方法結束後，線程就進入終止狀態；

·當線程調用了自身的sleep()方法或其他線程的join()方法，就會進入阻塞狀態(該狀態既停止當前線程，但並不釋放所佔有的資源)。當sleep()結束或join()結束後，該線程進入可運行狀態，繼續等待OS分配時間片；

·當線程剛進入可運行狀態(注意，還沒運行)，發現將要調用的資源被鎖牢(synchroniza,lock)，將會立即進入鎖池狀態，等待獲取鎖標記(這時的鎖池裡也許已經有了其他線程在等待獲取鎖標記，這時它們處於隊列狀態，既先到先得)，一旦線程獲得鎖標記後，就轉入可運行狀態，等待OS分配CPU時間片；

·當線程調用wait()方法後會進入等待隊列(進入這個狀態會釋放所佔有的所有資源，與阻塞狀態不同)，進入這個狀態後，是不能自動喚醒的，必須依靠其他線程調用notify()或notifyAll()方法才能被喚醒(由於notify()只是喚醒一個線程，但我們由不能確定具體喚醒的是哪一個線程，也許我們需要喚醒的線程不能夠被喚醒，因此在實際使用時，一般都用notifyAll()方法，喚醒有所線程)，線程被喚醒後會進入鎖池，等待獲取鎖標記。

·當線程調用stop方法，即可使線程進入消亡狀態，但是由於stop方法是不安全的，不鼓勵使用，大家可以通過run方法里的條件變通實現線程的stop。