java非同步方法

『壹』 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類型的對象。同步方法和同步塊之間的相互制約只限於同一個對象之間，所以靜態同步方法只受它所屬類的其它靜態同步方法的制約，而跟這個類的實例（對象）沒有關系。

『貳』 java中非同步處理和同步處理分別是什麼意思

舉個例子：A和B一起從某點出發到終點。

1. 同步就是只能A走完某一段然後停下，讓B開始走一段再停下，再讓A走。如此往復。簡單理解就是，必須是一段程序執行完後才能執行後面的程序。
   

2. 非同步就是，同一時間可能A和B同時都在往終點趕，此時不存在先後順序，就是說，兩個程序可以同時執行，稱為非同步。
   
   

『叄』 java隊列實現非同步執行

在整個思路上要調整一下

1、會有很多線程給一個隊列上添加任務

2、有一個或者多個線程逐個執行隊列的任務

考慮一下幾點：

1、沒有任務時，隊列執行線程處於等待狀態

2、添加任務時，激活隊列執行線程，全部run起來，首先搶到任務的執行，其他全部wait

給個小例子吧

packageorg;
importjava.util.LinkedList;
importjava.util.List;
publicclassQueues{
	publicstaticList<Task>queue=newLinkedList<Task>();
	/**
	*假如參數o為任務
	*@paramo
	*/
	publicstaticvoidadd(Taskt){
		synchronized(Queues.queue){
			Queues.queue.add(t);//添加任務
			Queues.queue.notifyAll();//激活該隊列對應的執行線程，全部Run起來
		}
	}
	staticclassTask{
		publicvoidtest(){
			System.out.println("我被執行了");
		}
	}
}

packageorg;
importjava.util.List;
{
	@Override
	publicvoidrun(){
		while(true){
			synchronized(Queues.queue){
				while(Queues.queue.isEmpty()){//
					try{
						Queues.queue.wait();//隊列為空時，使線程處於等待狀態
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
					System.out.println("wait...");
				}
				Queues.Taskt=Queues.queue.remove(0);//得到第一個
				t.test();//執行該任務
				System.out.println("end");
			}
		}
	}
	publicstaticvoidmain(String[]args){
		Exece=newExec();
		for(inti=0;i<2;i++){
			newThread(e).start();//開始執行時，隊列為空，處於等待狀態
		}
		//上面開啟兩個線程執行隊列中的任務，那就是先到先得了
		//添加一個任務測試
		Queues.Taskt=newQueues.Task();
		Queues.add(t);//執行該方法，激活所有對應隊列，那兩個線程就會開始執行啦
	}
	
}

上面的就是很簡單的例子了

『肆』 java 非同步調用方法

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

『伍』 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的同一個實例的同步方法時會進行同步.

『柒』 java如何實現線程非同步

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

『捌』 java中同步和非同步有什麼異同

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

相同的地方：

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

不同的地方：

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

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

(8)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基礎 網路

『玖』 java 非同步發送簡訊，非同步怎麼實現

java 非同步發送簡訊，非同步實現：
1，使用spring框架的非同步註解 @Async ，底層應該是一個線程。
2，簡單粗暴的方式：開一個線程
new Thread(new Runnable() {
public void run() {
//發送簡訊
}
}).start();
當然也可以高級一點，使用線程池。
3，更高端一點：使用消息隊列MQ

『拾』 java 非同步編程

用非同步輸入輸出流編寫Socket進程通信程序
在Merlin中加入了用於實現非同步輸入輸出機制的應用程序介麵包：java.nio（新的輸入輸出包，定義了很多基本類型緩沖(Buffer)），java.nio.channels(通道及選擇器等，用於非同步輸入輸出)，java.nio.charset（字元的編碼解碼）。通道(Channel)首先在選擇器(Selector)中注冊自己感興趣的事件，當相應的事件發生時，選擇器便通過選擇鍵(SelectionKey)通知已注冊的通道。然後通道將需要處理的信息，通過緩沖（Buffer）打包，編碼/解碼,完成輸入輸出控制。

通道介紹：
這里主要介紹ServerSocketChannel和 SocketChannel.它們都是可選擇的(selectable)通道，分別可以工作在同步和非同步兩種方式下（注意，這里的可選擇不是指可以選擇兩種工作方式，而是指可以有選擇的注冊自己感興趣的事件）。可以用channel.configureBlocking(Boolean )來設置其工作方式。與以前版本的API相比較，ServerSocketChannel就相當於ServerSocket(ServerSocketChannel封裝了ServerSocket),而SocketChannel就相當於Socket（SocketChannel封裝了Socket）。當通道工作在同步方式時，編程方法與以前的基本相似，這里主要介紹非同步工作方式。

所謂非同步輸入輸出機制，是指在進行輸入輸出處理時，不必等到輸入輸出處理完畢才返回。所以非同步的同義語是非阻塞（None Blocking）。在伺服器端，ServerSocketChannel通過靜態函數open()返回一個實例serverChl。然後該通道調用serverChl.socket().bind()綁定到伺服器某埠，並調用register（Selector sel, SelectionKey.OP_ACCEPT）注冊OP_ACCEPT事件到一個選擇器中（ServerSocketChannel只可以注冊OP_ACCEPT事件）。當有客戶請求連接時，選擇器就會通知該通道有客戶連接請求，就可以進行相應的輸入輸出控制了；在客戶端，clientChl實例注冊自己感興趣的事件後（可以是OP_CONNECT,OP_READ,OP_WRITE的組合），調用clientChl.connect(InetSocketAddress )連接伺服器然後進行相應處理。注意，這里的連接是非同步的，即會立即返回而繼續執行後面的代碼。

選擇器和選擇鍵介紹：
選擇器（Selector）的作用是：將通道感興趣的事件放入隊列中，而不是馬上提交給應用程序，等已注冊的通道自己來請求處理這些事件。換句話說，就是選擇器將會隨時報告已經准備好了的通道，而且是按照先進先出的順序。那麼，選擇器是通過什麼來報告的呢？選擇鍵(SelectionKey)。選擇鍵的作用就是表明哪個通道已經做好了准備，准備干什麼。你也許馬上會想到，那一定是已注冊的通道感興趣的事件。不錯，例如對於伺服器端serverChl來說，可以調用key.isAcceptable()來通知serverChl有客戶端連接請求。相應的函數還有：SelectionKey.isReadable(),SelectionKey.isWritable()。一般的，在一個循環中輪詢感興趣的事件（具體可參照下面的代碼）。如果選擇器中尚無通道已注冊事件發生，調用Selector.select()將阻塞，直到有事件發生為止。另外，可以調用selectNow()或者select(long timeout)。前者立即返回，沒有事件時返回0值；後者等待timeout時間後返回。一個選擇器最多可以同時被63個通道一起注冊使用。
應用實例：
下面是用非同步輸入輸出機制實現的客戶/伺服器實常式序――程序清單1（限於篇幅，只給出了伺服器端實現，讀者可以參照著實現客戶端代碼）：

程序類圖

public class NBlockingServer {
int port = 8000;
int BUFFERSIZE = 1024;
Selector selector = null;
ServerSocketChannel serverChannel = null;
HashMap clientChannelMap = null;//用來存放每一個客戶連接對應的套接字和通道

public NBlockingServer( int port ) {
this.clientChannelMap = new HashMap();
this.port = port;
}

public void initialize() throws IOException {
//初始化，分別實例化一個選擇器，一個伺服器端可選擇通道
this.selector = Selector.open();
this.serverChannel = ServerSocketChannel.open();
this.serverChannel.configureBlocking(false);
InetAddress localhost = InetAddress.getLocalHost();
InetSocketAddress isa = new InetSocketAddress(localhost, this.port );
this.serverChannel.socket().bind(isa);//將該套接字綁定到伺服器某一可用埠
}
//結束時釋放資源
public void finalize() throws IOException {
this.serverChannel.close();
this.selector.close();
}
//將讀入位元組緩沖的信息解碼
public String decode( ByteBuffer byteBuffer ) throws
CharacterCodingException {
Charset charset = Charset.forName( "ISO-8859-1" );
CharsetDecoder decoder = charset.newDecoder();
CharBuffer charBuffer = decoder.decode( byteBuffer );
String result = charBuffer.toString();
return result;
}
//監聽埠，當通道准備好時進行相應操作
public void portListening() throws IOException, InterruptedException {
//伺服器端通道注冊OP_ACCEPT事件
SelectionKey acceptKey =this.serverChannel.register( this.selector,
SelectionKey.OP_ACCEPT );
//當有已注冊的事件發生時,select()返回值將大於0
while (acceptKey.selector().select() > 0 ) {
System.out.println("event happened");
//取得所有已經准備好的所有選擇鍵
Set readyKeys = this.selector.selectedKeys();
//使用迭代器對選擇鍵進行輪詢
Iterator i = readyKeys.iterator();
while (i
else if ( key.isReadable() ) {//如果是通道讀准備好事件
System.out.println("Readable");
//取得選擇鍵對應的通道和套接字
SelectableChannel nextReady =
(SelectableChannel) key.channel();
Socket socket = (Socket) key.attachment();
//處理該事件，處理方法已封裝在類ClientChInstance中
this.readFromChannel( socket.getChannel(),
(ClientChInstance)
this.clientChannelMap.get( socket ) );
}
else if ( key.isWritable() ) {//如果是通道寫准備好事件
System.out.println("writeable");
//取得套接字後處理，方法同上
Socket socket = (Socket) key.attachment();
SocketChannel channel = (SocketChannel)
socket.getChannel();
this.writeToChannel( channel,"This is from server!");
}
}
}
}
//對通道的寫操作
public void writeToChannel( SocketChannel channel, String message )
throws IOException {
ByteBuffer buf = ByteBuffer.wrap( message.getBytes() );
int nbytes = channel.write( buf );
}
//對通道的讀操作
public void readFromChannel( SocketChannel channel, ClientChInstance clientInstance )
throws IOException, InterruptedException {
ByteBuffer byteBuffer = ByteBuffer.allocate( BUFFERSIZE );
int nbytes = channel.read( byteBuffer );
byteBuffer.flip();
String result = this.decode( byteBuffer );
//當客戶端發出」@exit」退出命令時，關閉其通道
if ( result.indexOf( "@exit" ) >= 0 ) {
channel.close();
}
else {
clientInstance.append( result.toString() );
//讀入一行完畢，執行相應操作
if ( result.indexOf( "\n" ) >= 0 ){
System.out.println("client input"+result);
clientInstance.execute();
}
}
}
//該類封裝了怎樣對客戶端的通道進行操作，具體實現可以通過重載execute()方法
public class ClientChInstance {
SocketChannel channel;
StringBuffer buffer=new StringBuffer();
public ClientChInstance( SocketChannel channel ) {
this.channel = channel;
}
public void execute() throws IOException {
String message = "This is response after reading from channel!";
writeToChannel( this.channel, message );
buffer = new StringBuffer();
}
//當一行沒有結束時，將當前字竄置於緩沖尾
public void append( String values ) {
buffer.append( values );
}
}

//主程序
public static void main( String[] args ) {
NBlockingServer nbServer = new NBlockingServer(8000);
try {
nbServer.initialize();
} catch ( Exception e ) {
e.printStackTrace();
System.exit( -1 );
}
try {
nbServer.portListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
}

程序清單1

小結：
從以上程序段可以看出，伺服器端沒有引入多餘線程就完成了多客戶的客戶/伺服器模式。該程序中使用了回調模式(CALLBACK)。需要注意的是，請不要將原來的輸入輸出包與新加入的輸入輸出包混用，因為出於一些原因的考慮，這兩個包並不兼容。即使用通道時請使用緩沖完成輸入輸出控制。該程序在Windows2000,J2SE1.4下，用telnet測試成功。