java線程非同步

1. java 線程池非同步任務需要處理非同步結果會阻塞嗎

1、關於非同步：java中非同步請求就是*調用*在發出之後，這個調用就直接返回了，所以沒有返回結果。換句話說，當一個非同步過程調用發出後，調用者不會立刻得到結果。而是在*調用*發出後，*被調用者*通過狀態、通知來通知調用者，或通過回調函數處理

2. java中同步和非同步有什麼異同

Java中交互方式分為同步和非同步兩種：

相同的地方：

都屬於交互方式，都是發送請求。

不同的地方：

同步交互：指發送一個請求,需要等待返回,然後才能夠發送下一個請求，有個等待過程；

非同步交互：指發送一個請求,不需要等待返回,隨時可以再發送下一個請求，即不需要等待。區別：一個需要等待，一個不需要等待，在部分情況下，我們的項目開發中都會優先選擇不需要等待的非同步交互方式。

(2)java線程非同步擴展閱讀：

Java，是由Sun Microsystems公司於1995年5月推出的Java程序設計語言和Java平台的總稱。用Java實現的HotJava瀏覽器（支持Java applet）顯示了Java的魅力：跨平台、動態的Web、Internet計算。從此，Java被廣泛接受並推動了Web的迅速發展，常用的瀏覽器現均支持Java applet

Java是一種簡單的，面向對象的，分布式的，解釋型的，健壯安全的，結構中立的，可移植的，性能優異、多線程的動態語言。

當1995年SUN推出Java語言之後，全世界的目光都被這個神奇的語言所吸引。那麼Java到底有何神奇之處呢？

Java語言其實最早誕生於1991年，起初被稱為OAK語言，是SUN公司為一些消費性電子產品而設計的一個通用環境。他們最初的目的只是為了開發一種獨立於平台的軟體技術，而且在網路出現之前，OAK可以說是默默無聞，甚至差點夭折。但是，網路的出現改變了OAK的命運。

參考資料:java基礎 網路

3. 如何在java中獲取線程非同步執行之後的結果

java中提供了Future<V>介面和實現了Future介面的FutureTask<V> 類來將線程執行之後的結果返回（通過get()方法）。
1.Future<V>介面
Runnable介面執行任務是不返回任何值的，Runnable的run()方法的執行結果是void,而Future介面的call方法是有返回結果的，這是Runnable跟Future的區別之一，它們的另一個不同之處就是實現了Runnable介面的任務執行是調用ExecutorService的execute(Runnable task)方法，而實現了Future介面的任務是調用ExecutorService的submit(Future task)方法。調用Future的get()方法就能直接得到任務的返回值，該方法會一直阻塞直到任務的結果出來為止，我們可以調用Future的isDone()方法來判斷該任務的結果是否准備就緒。
[java] view plain
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestFuture {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Future result1 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += i;
}
return sum;
}
});
Future result2 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 10; i < 100; i++) {
sum += i;
}
return sum;
}
});
executor.shutdown();
System.out.println(result1.get() + result2.get());
}
}
2.FutureTask類
FutureTask實現了Future介面，將一個Callable實例作為參數傳給它，就能創建一個FutureTask實例，然後用ExecutorService的submit方法來執行這個實例。最後同樣是用get方法獲取線程執行後的結果。
[plain] view plain
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestFutureTask {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Callable task = new Callable() {
@Override
public String call() throws Exception {
return "結果";
}
};
FutureTask ft = new FutureTask(task);
executor.submit(ft);
System.out.println(ft.get());
executor.shutdown();
}
}empty

4. java同步和非同步的區別

java同步和非同步的區別如下：

一、根據情況需要專門的線程方式

如果數據將在線程間共享.例如正在寫的數據以後可能被另一個線程讀到,或者正在讀的數據可能已經被另一個線程寫過了,那麼這些數據就是共享數據,必須進行同步存取.

當應用程序在對象上調用了一個需要花費很長時間來執行的方法,並且不希望讓程序等待方法的返回時,就應該使用非同步編程,在很多情況下採用非同步途徑往往更有效率.

二、應用不同：

• Java同步:

  基本概念:每個Object都會有1個鎖.同步就是串列使用一些資源.

(說明:以下有些例子為了突出重點,省略了不必要的代碼.非凡是省掉了一些成員變數,就是需要同步的對象.)

1. 多線程中對共享、可變的數據進行同步.

對於函數中的局部變數沒必要進行同步.

對於不可變數據,也沒必要進行同步.

多線程中訪問共享可變數據才有必要.

2. 單個線程中可以使用synchronized,而且可以嵌套,但無意義.

class Test {

public static void main(String[] args) {

Test t = new Test();

synchronized(t) {

synchronized(t) {

System.out.println("ok!");

}

}

}

}

3. 對象實例的鎖

class Test{

public synchronized void f1(){

//do something here

}

public void f2(){

synchronized(this){

//do something here

}

}

}

上面的f1()和f2()效果一致, synchronized取得的鎖都是Test某個實列(this)的鎖.

比如: Test t = new Test();

線程A調用t.f2()時, 線程B無法進入t.f1(),直到t.f2()結束.

作用: 多線程中訪問Test的同一個實例的同步方法時會進行同步.

4. class的鎖

class Test{

final static Object o= new Object();

public static synchronized void f1(){

//do something here

}

public static void f2(){

synchronized(Test.class){

//do something here

}

}

public static void f3(){

try {

synchronized (Class.forName("Test")) {

//do something here

}

}

catch (ClassNotFoundException ex) {

}

}

public static void g(){

synchronized(o){

//do something here

}

}

}

上面f1(),f2(),f3(),g()效果一致

f1(),f2(),f3()中synchronized取得的鎖都是Test.class的鎖.

g()是自己產生一個對象o,利用o的鎖做同步

作用: 多線程中訪問此類或此類任一個實例的同步方法時都會同步. singleton模式lazily initializing屬於此類.

5. static method

class Test{

private static int v = 0;

public static void f1(){

//do something, 但函數中沒用用到v

}

public synchronized static void f2(){

//do something, 函數中對v進行了讀/寫.

}

}

多線程中使用Test的某個實列時,

(1) f1()是線程安全的,不需要同步

(2) f2()這個靜態方法中使用了函數外靜態變數,所以需要同步.

• Java非同步:

  1、 它要能適應不同類型的請求:

  本節用 makeString來說明要求有返回值的請求.用displayString來說明不需要返回值的請求.

  2、 要能同時並發處理多個請求,並能按一定機制調度:

  本節將用一個隊列來存放請求,所以只能按FIFO機制調度,你可以改用LinkedList,就可以簡單實現一個優先順序(優先順序高的addFirst,低的addLast).

  3、有能力將調用的邊界從線程擴展到機器間(RMI)

  4、分離過度耦合,如分離調用句柄(取貨憑證)和真實數據的實現.分離調用和執行的過程,可以盡快地將調返回.

  現在看具體的實現:

  public interface Axman {

  Result resultTest(int count,char c);

  void noResultTest(String str);

  }

  這個介面有兩個方法要實現,就是有返回值的調用resultTest和不需要返回值的調用

  noResultTest, 我們把這個介面用一個代理類來實現,目的是將方法調用轉化為對象,這樣就可以將多個請求(多個方法調)放到一個容器中緩存起來,然後統一處理,因為 Java不支持方法指針,所以把方法調用轉換為對象,然後在這個對象上統一執行它們的方法,不僅可以做到非同步處理,而且可以將代表方法調用的請求對象序列化後通過網路傳遞到另一個機器上執行(RMI).這也是Java回調機制最有力的實現.

  一個簡單的例子.

  如果 1: 做A

  如果 2: 做B

  如果 3: 做C

  如果有1000個情況,你不至於用1000個case吧?以後再增加呢?

  所以如果C/C++程序員,會這樣實現: (c和c++定義結構不同)

  type define struct MyStruct{

  int mark;

  (*fn) ();

  } MyList;

  然後你可以聲明這個結構數據:

  {1,A,

  2,B

  3,C

  }

  做一個循環:

  for(i=0;i<length;i++) {

  if(數據組[i].mark == 傳入的值) (數據組[i].*fn)();

  }

  簡單說c/c++中將要被調用的涵數可以被保存起來,然後去訪問,調用,而Java中,我們無法將一個方法保存,除了直接調用,所以將要調用的方法用子類來實現,然後把這些子類實例保存起來,然後在這些子類的實現上調用方法:

  interface My{

  void test();

• }

5. java 總結幾種線程非同步轉同步的方法

以Java語言為例：
用synchronized關鍵字修飾同步方法。
同步有幾種實現方法分別是synchronized,wait與notify
wait():使一個線程處於等待狀態，並且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。
notify():喚醒一個處於等待狀態的線程，注意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且不是按優先順序。
Allnotity():喚醒所有處入等待狀態的線程，注意並不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
同步是多線程中的重要概念。同步的使用可以保證在多線程運行的環境中，程序不會產生設計之外的錯誤結果。同步的實現方式有兩種，同步方法和同步塊，這兩種方式都要用到synchronized關鍵字。
給一個方法增加synchronized修飾符之後就可以使它成為同步方法，這個方法可以是靜態方法和非靜態方法，但是不能是抽象類的抽象方法，也不能是介面中的介面方法。下面代碼是一個同步方法的示例：
public synchronized void aMethod() {
// do something
}
public static synchronized void anotherMethod() {
// do something
}

線程在執行同步方法時是具有排它性的。當任意一個線程進入到一個對象的任意一個同步方法時，這個對象的所有同步方法都被鎖定了，在此期間，其他任何線程都不能訪問這個對象的任意一個同步方法，直到這個線程執行完它所調用的同步方法並從中退出，從而導致它釋放了該對象的同步鎖之後。在一個對象被某個線程鎖定之後，其他線程是可以訪問這個對象的所有非同步方法的。
同步塊是通過鎖定一個指定的對象，來對同步塊中包含的代碼進行同步；而同步方法是對這個方法塊里的代碼進行同步，而這種情況下鎖定的對象就是同步方法所屬的主體對象自身。如果這個方法是靜態同步方法呢？那麼線程鎖定的就不是這個類的對象了，也不是這個類自身，而是這個類對應的java.lang.Class類型的對象。同步方法和同步塊之間的相互制約只限於同一個對象之間，所以靜態同步方法只受它所屬類的其它靜態同步方法的制約，而跟這個類的實例（對象）沒有關系。

6. java中使用非同步線程池有什麼優缺點

缺點是難以保證數據的准確性 （data integration），還有一個是需要更多的資源。

優點是可以並列處理一些工作，從而減少一些不必要的等待時間（blocking）

非同步線程在 UI 和 網路連接方面很常見的

7. java如何實現線程非同步

Thread t=new Thread(){
public void run(){
//保存信息操作
}
}
t.start();
//同時做別的事情.

8. java 非同步調用方法

asynchronous call（非同步調用）
一個可以無需等待被調用函數的返回值就讓操作繼續進行的方法
中文名
非同步調用
外文名
asynchronous call
領域
函數
傑作
線程
。
。
快速
導航
實戰用法非同步調用使用方法
舉例
非同步調用就是你 喊 你朋友吃飯 ，你朋友說知道了 ，待會忙完去找你 ，你就去做別的了。
同步調用就是你 喊 你朋友吃飯 ，你朋友在忙 ，你就一直在那等，等你朋友忙完了 ，你們一起去。
實戰用法
操作系統發展到今天已經十分精巧，線程就是其中一個傑作。操作系統把 CPU 處理時間劃分成許多短暫時間片，在時間 T1 執行一個線程的指令，到時間 T2又執行下一線程的指令，各線程輪流執行，結果好象是所有線程在並肩前進。這樣，編程時可以創建多個線程，在同一期間執行，各線程可以「並行」完成不同的任務。
在單線程方式下，計算機是一台嚴格意義上的馮·諾依曼式機器，一段代碼調用另一段代碼時，只能採用同步調用，必須等待這段代碼執行完返回結果後，調用方才能繼續往下執行。有了多線程的支持，可以採用非同步調用，調用方和被調方可以屬於兩個不同的線程，調用方啟動被調方線程後，不等對方返回結果就繼續執行後續代碼。被調方執行完畢後，通過某種手段通知調用方：結果已經出來，請酌情處理。

9. Java中的線程同步與非同步如何理解

線程，有時被稱為輕量級進程(Lightweight Process，LWP)，是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC)，寄存器集合和堆棧組成。

另外，線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不擁有系統資源，只擁有一點兒在運行中必不可少的資源，但它可與同屬一個進程的其它線程共享進程所擁有的全部資源。

一個線程可以創建和撤消另一個線程，同一進程中的多個線程之間可以並發執行。由於線程之間的相互制約，致使線程在運行中呈現出間斷性。線程也有就緒、阻塞和運行三種基本狀態。

就緒狀態是指線程具備運行的所有條件，邏輯上可以運行，在等待處理機;運行狀態是指線程佔有處理機正在運行;阻塞狀態是指線程在等待一個事件(如某個信號量)，邏輯上不可執行。每一個程序都至少有一個線程，若程序只有一個線程，那就是程序本身。

線程是程序中一個單一的順序控制流程。進程內一個相對獨立的、可調度的執行單元，是系統獨立調度和分派CPU的基本單位指運行中的程序的調度單位。在單個程序中同時運行多個線程完成不同的工作，稱為多線程。

同步就是只能A走完某一段然後停下，讓B開始走一段再停下，再讓A走。。如此往復。簡單理解就是，必須是一段程序執行完後才能執行後面的程序。。
非同步就是，同一時間可能A和B同時都在往終點趕，此時不存在先後順序，就是說，兩個程序可以同時執行，稱為非同步。

10. 如何用Java回調和線程實現非同步調用

軟體模塊之間的調用關系可以分為兩大類:即同步調用和非同步調用。在同步調用中,一段代碼(主調方)調用另一段代碼(被調方),主調方必須等待這段代碼執行完成返回結果後,才能繼續往下執行,所以,同步調用是一種阻塞式調用,主調方代碼一直阻塞等待直到被調方返回為止。同步調用相對比較直觀,也是大部分編程語言直接支持的一種調用方式。但是,同步調用在處理比較耗時的情況下會嚴重影響程序性能,影響人機交互的瞬時反應。例如,某個程序需要訪問資料庫獲取大量數據,然後根據這些數據進行一系列處理,將處理結果顯示在程序主窗口。由於資料庫訪問和大量數據的處理都是耗時的工作,在這個工作完成之前,處理結果遲遲不能顯示,用戶點擊滑鼠也不會立即得到響應,讓用戶感到整個程序顯得很沉重。面對這樣一些需要比較長時間才能完成的應用場景,我們需要採用一種非阻塞式調用方式,即非同步調用方式