java多線程返回值

⑴ java多線程的幾種寫法

有三種：
(1)繼承類，重寫run函數
創建：
class xx extends Thread{
public void run(){
Thread.sleep(1000) //線程休眠1000毫秒，sleep使線程進入Block狀態，並釋放資源
}}
開啟線程：
對象.start() //啟動線程，run函數運行
(2)實現Runnable介面，重寫run函數
開啟線程：
Thread t = new Thread(對象) //創建線程對象
t.start()
(3)實現Callable介面，重寫call函數
Callable是類似於Runnable的介面，實現Callable介面的類和實現Runnable的類都是可被其它線程執行的任務。
Callable和Runnable有幾點不同:
①Callable規定的方法是call()，而Runnable規定的方法是run().
②Callable的任務執行後可返回值，而Runnable的任務是不能返回值的
③call()方法可拋出異常，而run()方法是不能拋出異常的。
④運行Callable任務可拿到一個Future對象，Future表示非同步計算的結果。它提供了檢查計算是否完成的方法,以等
待計算的完成,並檢索計算的結果.通過Future對象可了解任務執行情況,可取消任務的執行,還可獲取任務執行的結果

⑵ 各位大拿 java 多線程 同時調用單例對象帶有返回值的方法 會不出線程之間出錯

多線程同時調用單例對象的方法，如果你方法里用到了共享變數(共享變數就是類屬性)， 而共享變數又沒有做同步(synchronized)， 那就會出你說的問題了。 去掉共享變數，只在方法里使用私有變數，就沒問題了。
-- 注意，如果共享變數是只讀的，也不會出問題。

⑶ java多線程問題 跳過run方法裡面的if執行

多線程

35. 並行和並發有什麼區別？

並行是指兩個或者多個事件在同一時刻發生；而並發是指兩個或多個事件在同一時間間隔發生。

並行是在不同實體上的多個事件，並發是在同一實體上的多個事件。

在一台處理器上「同時」處理多個任務，在多台處理器上同時處理多個任務。如hadoop分布式集群。

所以並發編程的目標是充分的利用處理器的每一個核，以達到最高的處理性能。

36. 線程和進程的區別？

簡而言之，進程是程序運行和資源分配的基本單位，一個程序至少有一個進程，一個進程至少有一個線程。進程在執行過程中擁有獨立的握脊內存單元，而多個線程共享內存資源，減少切換次數，從而效率更高。線程是進程的一個實體，是cpu調度和分派的基本單位，是比程序更小的能獨立運行的基本單位。同一進程中的多個線程之間可以並發執行。

37. 守護線程是什麼？

守護線程(即daemon thread)，是個服務線程，准確地來說就是服務其他的線程。

38. 創建線程有哪幾種方式？

①. 繼承Thread類創建線程類

定義Thread類的子類，並重寫該類的run方法，該run方法的方法體就代表了線程要完成的任務。因此把run方法稱為執行體。

創建Thread子類的實例，即創建了線程對象。

調用線程對象的start方法來啟動該線程。

②. 通過Runnable介面創建線程類

定義runnable介面的實現類，並重寫該介面的run方法，該run方法的方法體同樣是該線程的線程執行體。

創建 Runnable實現類的實例，並依此實例作為Thread的target來創建Thread對象，該Thread對象才是真正的線程對象。

調用線程對象的start方法來啟動該線程。

③. 通過Callable和Future創建線程

創建Callable介面的實現類，並實現call方法，該call方法將作為線程執行體，並且有返回值。

創建Callable實現類的實例，使用FutureTask類來包裝Callable對象，該FutureTask對象封裝了該Callable對象的call方法的返回值。

使用FutureTask對象作為Thread對象的target創建並啟動新線程。

調用FutureTask對象的get方法來獲得子線程執行結束後的返回值。

39. 說一下 runnable 和 callable 有什麼區別？

有點深的問題了，也看出一個Java程序員學習知識的廣度。

Runnable介面中的run方法的返回值是void，它做的事情只是純粹地去執行run方法中的代碼而已；

Callable介面中的call方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取非同步執行的結果。

40. 線程有哪些狀態？

線程通常都有五種狀態，創建、就緒、運行、阻塞和死亡。

創建狀態。在生成線程對象，並沒有調用該對象的start方法，這是線程處於創建狀態。

就緒狀態。當調用了線程對象的start方法之後，該線段侍滲程就進入了就緒狀態，但是此時線程調度程序還沒有把該線程設置為當前線程，此時處於就緒狀態。在談冊線程運行之後，從等待或者睡眠中回來之後，也會處於就緒狀態。

運行狀態。線程調度程序將處於就緒狀態的線程設置為當前線程，此時線程就進入了運行狀態，開始運行run函數當中的代碼。

阻塞狀態。線程正在運行的時候，被暫停，通常是為了等待某個時間的發生(比如說某項資源就緒)之後再繼續運行。sleep,suspend，wait等方法都可以導致線程阻塞。

死亡狀態。如果一個線程的run方法執行結束或者調用stop方法後，該線程就會死亡。對於已經死亡的線程，無法再使用start方法令其進入就緒

41. sleep 和 wait 有什麼區別？

sleep：方法是線程類(Thread)的靜態方法，讓調用線程進入睡眠狀態，讓出執行機會給其他線程，等到休眠時間結束後，線程進入就緒狀態和其他線程一起競爭cpu的執行時間。因為sleep 是static靜態的方法，他不能改變對象的機鎖，當一個synchronized塊中調用了sleep 方法，線程雖然進入休眠，但是對象的機鎖沒有被釋放，其他線程依然無法訪問這個對象。

wait：wait是Object類的方法，當一個線程執行到wait方法時，它就進入到一個和該對象相關的等待池，同時釋放對象的機鎖，使得其他線程能夠訪問，可以通過notify，notifyAll方法來喚醒等待的線程

42. notify和 notifyAll有什麼區別？

如果線程調用了對象的 wait方法，那麼線程便會處於該對象的等待池中，等待池中的線程不會去競爭該對象的鎖。

當有線程調用了對象的 notifyAll方法(喚醒所有 wait 線程)或 notify方法(只隨機喚醒一個 wait 線程)，被喚醒的的線程便會進入該對象的鎖池中，鎖池中的線程會去競爭該對象鎖。也就是說，調用了notify後只要一個線程會由等待池進入鎖池，而notifyAll會將該對象等待池內的所有線程移動到鎖池中，等待鎖競爭。

優先順序高的線程競爭到對象鎖的概率大，假若某線程沒有競爭到該對象鎖，它還會留在鎖池中，唯有線程再次調用 wait方法，它才會重新回到等待池中。而競爭到對象鎖的線程則繼續往下執行，直到執行完了 synchronized 代碼塊，它會釋放掉該對象鎖，這時鎖池中的線程會繼續競爭該對象鎖。

43. 線程的 run和 start有什麼區別？

每個線程都是通過某個特定Thread對象所對應的方法run來完成其操作的，方法run稱為線程體。通過調用Thread類的start方法來啟動一個線程。

start方法來啟動一個線程，真正實現了多線程運行。這時無需等待run方法體代碼執行完畢，可以直接繼續執行下面的代碼；這時此線程是處於就緒狀態， 並沒有運行。然後通過此Thread類調用方法run來完成其運行狀態， 這里方法run稱為線程體，它包含了要執行的這個線程的內容， Run方法運行結束， 此線程終止。然後CPU再調度其它線程。

run方法是在本線程里的，只是線程里的一個函數,而不是多線程的。 如果直接調用run,其實就相當於是調用了一個普通函數而已，直接待用run方法必須等待run方法執行完畢才能執行下面的代碼，所以執行路徑還是只有一條，根本就沒有線程的特徵，所以在多線程執行時要使用start方法而不是run方法。

44. 創建線程池有哪幾種方式？

①. newFixedThreadPool(int nThreads)

創建一個固定長度的線程池，每當提交一個任務就創建一個線程，直到達到線程池的最大數量，這時線程規模將不再變化，當線程發生未預期的錯誤而結束時，線程池會補充一個新的線程。

②. newCachedThreadPool

創建一個可緩存的線程池，如果線程池的規模超過了處理需求，將自動回收空閑線程，而當需求增加時，則可以自動添加新線程，線程池的規模不存在任何限制。

③. newSingleThreadExecutor

這是一個單線程的Executor，它創建單個工作線程來執行任務，如果這個線程異常結束，會創建一個新的來替代它；它的特點是能確保依照任務在隊列中的順序來串列執行。

④. newScheledThreadPool(int corePoolSize)

創建了一個固定長度的線程池，而且以延遲或定時的方式來執行任務，類似於Timer。

45. 線程池都有哪些狀態？

線程池有5種狀態：Running、ShutDown、Stop、Tidying、Terminated

⑷ java大數據 多線程寫文件

1、採用public static的變數存儲這一數值，每個線程都往這一共有靜態變數里寫入已復制大內小。 2、採用Callable方式實現多線程，容將結果作為返回值返回到主線程。這一方法只能在所有子線程都完成之後才能通過future獲取。

⑸ java 線程中的值如何返回

如果是java5的話，那麼Java5新增了Callable介面獲得線程的返回值，用法如下

packagecom.ronniewang;


importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;


{


privatestaticfinalintSLEEP_MILLS=3000;


privatestaticfinalintSECOND_MILLS=1000;


privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;


=Executors.newCachedThreadPool();


/**
*在創建多線程程序的時候，我們常實現Runnable介面，Runnable沒有返回值，要想獲得返回值，Java5提供了一個新的介面Callable
*/
publicstaticvoidmain(String[]args){


newGetReturnValueFromCallable().testCallable();
}


privatevoidtestCallable(){


/**
*Callable需要實現的是call()方法，而不是run()方法，返回值的類型有Callable的類型參數指定，
*Callable只能由ExecutorService.submit()執行，正常結束後將返回一個future對象
*/
Future<String>future=executorService.submit(newCallable<String>(){


publicStringcall()throwsException{


Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});


while(true){
/**
*獲得future對象之前可以使用isDone()方法檢測future是否完成，完成後可以調用get()方法獲得future的值，
*如果直接調用get()方法，get()方法將阻塞值線程結束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}
packagecom.ronniewang;


importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;


{


privatestaticfinalintSLEEP_MILLS=3000;


privatestaticfinalintSECOND_MILLS=1000;


privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;


=Executors.newCachedThreadPool();


/**
*在創建多線程程序的時候，我們常實現Runnable介面，Runnable沒有返回值，要想獲得返回值，Java5提供了一個新的介面Callable
*/
publicstaticvoidmain(String[]args){


newGetReturnValueFromCallable().testCallable();
}


privatevoidtestCallable(){


/**
*Callable需要實現的是call()方法，而不是run()方法，返回值的類型有Callable的類型參數指定，
*Callable只能由ExecutorService.submit()執行，正常結束後將返回一個future對象
*/
Future<String>future=executorService.submit(newCallable<String>(){


publicStringcall()throwsException{


Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});


while(true){
/**
*獲得future對象之前可以使用isDone()方法檢測future是否完成，完成後可以調用get()方法獲得future的值，
*如果直接調用get()方法，get()方法將阻塞值線程結束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}

輸出結果：
after3seconds,wewillgetfuture
after2seconds,wewillgetfuture
after1seconds,wewillgetfuture
Ifromcallable

⑹ 使用java多線程列印0到1000輸出且不重復，如何實現

這其實是一個多線程，資源共享的問題。實現Runnable介面就可以了。

截圖是一個多線程資源共享回的例子，每個線答程可以互相知道ticket的值，這樣就不會重復。

把ticket初始為0，每個線程列印出ticket的值，打完+1。下一個線程再列印ticket就是+1之後的值。然後再判斷ticket的值，>=1000的時候停止線程。

詳細的你可以看看：

java多線程總結 - Rollen Holt - 博客園

http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html

完全可以解決你的需求

⑺ 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多線程問題，想讓每次線程運行後都能返回值給成員變數，要如何修改

把a定義成公共的，在thread里i++時，a也跟著++就行，，不過你的代碼怎麼構造出了好幾個線程？？？如果這幾個線程公用一個i變數，那麼Thread1需要實現Runnable介面，而不是繼承Thread類
publicclassXianChengNew{
	publicstaticinta=0;

	publicstaticvoidmain(String[]args){
		Thread1t1=null;
		t1=newThread1(a);
		t1.start();
		booleanflag=true;
		while(flag){
			if(!t1.isAlive()){
				flag=false;
			}
		}
		System.out.println("Maina="+a);
	}
}

classThread1extendsThread{
	privateinti=0;

	publicThread1(inti){
		super();
		this.i=i;
	}

	@Override
	publicvoidrun(){
		//super.run();
		//for(ints=0;s<100;s++){
		add();
		//}
	}

	synchronizedvoidadd(){
		for(intc=0;c<5;c++){
			i++;
			XianChengNew.a++;
			System.out.println("i="+i);
			System.out.println("a="+XianChengNew.a);
		}
	}
}

⑼ 多線程有哪些實現方式

java多線程的幾種實現方式：閉耐困
1.繼承Thread類，重寫run方法
2.實現Runnable介面，重寫轎念run方法，實現Runnable介面的實現類的實例對象作為Thread構造函數的target
3.通過Callable和FutureTask創建線程
4.通過線程池創建線程 （上一篇已經講過了）
前面兩種可以歸結為一類：無返回值，原因很簡單，通過重寫run方法，run方式的返畝判回值是void，所以沒有辦法返回結果
後面兩種可以歸結成一類：有返回值，通過Callable介面，就要實現call方法，這個方法的返回值是Object，所以返回的結果可以放在Object對象中

⑽ java多線程編程代碼如下，輸出結果如下:

首先，你同步的是具體的某個Test實例， 對於那個實例來說，實際上只有一個線程訪問了那個代碼塊，但是sum和other卻是多個線程同時去進行訪問，實際上這是不安全的，如果你想實現每次都輸出10000的效果，那麼正確的應該是在Test.class上加鎖，而不是獲取Test實例的鎖，修改後的代碼如下：

publicclassTestextendsThread{

publicstaticintsum=10000;

publicstaticintother=0;

publicvoidgetMoney(){
synchronized(Test.class){

System.out.println(Thread.currentThread().getName()+"開始執行");
sum=sum-100;

System.out.println("sum-100");

other=other+100;

System.out.println("other+100");

System.out.println(sum+other);
System.out.println(Thread.currentThread().getName()+"執行完成");
}

}

publicvoidrun(){

getMoney();

}

publicstaticvoidmain(String[]agrs){

Threadt[]=newThread[10];

for(inti=0;i<=9;i++){

t[i]=newTest();

t[i].start();

}

}

}

// 上面代碼能得到你的結果