『壹』 在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()方法。
你好，本題已解答,如果滿意
請點右下角「採納答案」。
『貳』 java 多線程有幾種實現方法
1、繼承Thread類實現多線程
繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable介面的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：
[java] view plain
public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}
在合適的地方啟動線程如下：
[java] view plain
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
2、實現Runnable介面方式實現多線程
如果自己的類已經extends另一個類，就無法直接extends Thread，此時，必須實現一個Runnable介面，如下：
[java] view plain
public class MyThread extends OtherClass implements Runnable {
public void run() {
System.out.println("MyThread.run()");
}
}
為了啟動MyThread，需要首先實例化一個Thread，並傳入自己的MyThread實例：
[java] view plain
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
事實上，當傳入一個Runnable target參數給Thread後，Thread的run()方法就會調用target.run()，參考JDK源代碼：
[java] view plain
public void run() {
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中多線程如何互相操作
Java線程：線程的交互
SCJP5學習筆記
線程交互是比較復雜的問題，SCJP要求不很基礎：給定一個場景，編寫代碼來恰當使用等待、通知和通知所有線程。
一、線程交互的基礎知識
SCJP所要求的線程交互知識點需要從java.lang.Object的類的三個方法來學習：
void notify()
喚醒在此對象監視器上等待的單個線程。
void notifyAll()
喚醒在此對象監視器上等待的所有線程。
void wait()
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法。
當然，wait()還有另外兩個重載方法：
void wait(long timeout)
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量。
void wait(long timeout, int nanos)
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量。
以上這些方法是幫助線程傳遞線程關心的時間狀態。
關於等待/通知，要記住的關鍵點是：
必須從同步環境內調用wait()、notify()、notifyAll()方法。線程不能調用對象上等待或通知的方法，除非它擁有那個對象的鎖。
wait()、notify()、notifyAll()都是Object的實例方法。與每個對象具有鎖一樣，每個對象可以有一個線程列表，他們等待來自該信號（通知）。線程通過執行對象上的wait()方法獲得這個等待列表。從那時候起，它不再執行任何其他指令，直到調用對象的notify()方法為止。如果多個線程在同一個對象上等待，則將只選擇一個線程（不保證以何種順序）繼續執行。如果沒有線程等待，則不採取任何特殊操作。
下面看個例子就明白了：
/**
* 計算輸出其他線程鎖計算的數據
*
* @author leimin 2008-9-15 13:20:38
*/
public class ThreadA {
public static void main(String[] args) {
ThreadB b = new ThreadB();
//啟動計算線程
b.start();
//線程A擁有b對象上的鎖。線程為了調用wait()或notify()方法，該線程必須是那個對象鎖的擁有者
synchronized (b) {
try {
System.out.println("等待對象b完成計算。。。");
//當前線程A等待
b.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("b對象計算的總和是：" + b.total);
}
}
}
/**
* 計算1+2+3 ... +100的和
*
* @author leimin 2008-9-15 13:20:49
*/
public class ThreadB extends Thread {
int total;
public void run() {
synchronized (this) {
for (int i = 0; i < 101; i++) {
total += i;
}
//（完成計算了）喚醒在此對象監視器上等待的單個線程，在本例中線程A被喚醒
notify();
}
}
}
等待對象b完成計算。。。
b對象計算的總和是：5050
Process finished with exit code 0
千萬注意：
當在對象上調用wait()方法時，執行該代碼的線程立即放棄它在對象上的鎖。然而調用notify()時，並不意味著這時線程會放棄其鎖。如果線程榮然在完成同步代碼，則線程在移出之前不會放棄鎖。因此，只要調用notify()並不意味著這時該鎖變得可用。
二、多個線程在等待一個對象鎖時候使用notifyAll()
在多數情況下，最好通知等待某個對象的所有線程。如果這樣做，可以在對象上使用notifyAll()讓所有在此對象上等待的線程沖出等待區，返回到可運行狀態。
下面給個例子：
/**
* 計算線程
*
* @author leimin 2008-9-20 11:15:46
*/
public class Calculator extends Thread {
int total;
public void run() {
synchronized (this) {
for (int i = 0; i < 101; i++) {
total += i;
}
}
//通知所有在此對象上等待的線程
notifyAll();
}
}
/**
* 獲取計算結果並輸出
*
* @author leimin 2008-9-20 11:15:22
*/
public class ReaderResult extends Thread {
Calculator c;
public ReaderResult(Calculator c) {
this.c = c;
}
public void run() {
synchronized (c) {
try {
System.out.println(Thread.currentThread() + "等待計算結果。。。");
c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "計算結果為：" + c.total);
}
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
//啟動三個線程，分別獲取計算結果
new ReaderResult(calculator).start();
new ReaderResult(calculator).start();
new ReaderResult(calculator).start();
//啟動計算線程
calculator.start();
}
}
運行結果：
Thread[Thread-1,5,main]等待計算結果。。。
Thread[Thread-2,5,main]等待計算結果。。。
Thread[Thread-3,5,main]等待計算結果。。。
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException: current thread not owner
at java.lang.Object.notifyAll(Native Method)
at threadtest.Calculator.run(Calculator.java:18)
Thread[Thread-1,5,main]計算結果為：5050
Thread[Thread-2,5,main]計算結果為：5050
Thread[Thread-3,5,main]計算結果為：5050
Process finished with exit code 0
運行結果表明，程序中有異常，並且多次運行結果可能有多種輸出結果。這就是說明，這個多線程的交互程序還存在問題。究竟是出了什麼問題，需要深入的分析和思考，下面將做具體分析。
實際上，上面這個代碼中，我們期望的是讀取結果的線程在計算線程調用notifyAll()之前等待即可。 但是，如果計算線程先執行，並在讀取結果線程等待之前調用了notify()方法，那麼又會發生什麼呢？這種情況是可能發生的。因為無法保證線程的不同部分將按照什麼順序來執行。幸運的是當讀取線程運行時，它只能馬上進入等待狀態----它沒有做任何事情來檢查等待的事件是否已經發生。 ----因此，如果計算線程已經調用了notifyAll()方法，那麼它就不會再次調用notifyAll()，----並且等待的讀取線程將永遠保持等待。這當然是開發者所不願意看到的問題。
因此，當等待的事件發生時，需要能夠檢查notifyAll()通知事件是否已經發生。
通常，解決上面問題的最佳方式是將
×××××××××××××××××××××××××××××
以上來自http://lavasoft.blog.51cto.com/62575/99157
這是一個系列線程的問題。。舉例簡單，但是很實用
『肆』 在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。