非同步編程
A. 什麼是非同步編程，什麼是javascript非同步編程，為什麼需要非同步編程
傳統的同步編程是一種請求響應模型，調用一個方法，等待其響應返回.
B. 與非同步編程的區別，非同步有哪些優點，為什麼要非同步
failover
其原理是在一條非同步復制通道上配置多個可用復制源，當某個復制源不可用時（宕機、復制鏈路中斷），且 slave 的 IO 線程嘗試重連無效，自動根據權重選擇新的源繼續同步。
准備一個 MGR 集群和單實例，模擬復制鏈路切換，當 primary 故障，slave 自動切換到其他節點。dbdeployerdeployreplication--topology=group8.0.22--single-primarydbdeployer deploy single 8.0.22
change master to master_user='msandbox',master_password='msandbox', master_host='127.0.0.1',master_auto_position=1,source_connection_auto_failover=1,master_port=23223,master_retry_count=6,master_connect_retry=10 for channel 'mgr-single';
在 master_retry_count 和 master_connect_retry 的設置上要考慮嘗試重連多久才切換復制源。
配置 asynchronous connection auto failover 的兩個函數：
asynchronous_connection_failover_add_source(channel-name,host,port,network-namespace,weight)
asynchronous_connection_failover_delete_source(channel-name,host,port,network-namespace)
權重值大的被優先順序選擇，可以配合MGR的選舉權重配置 asynchronous_connection_failover 的權重。當 MGR 節點切換，非同步復制也能切換到新的主節點。
SELECT asynchronous_connection_failover_add_source('mgr-single','127.0.0.1',23223,null,100); SELECT asynchronous_connection_failover_add_source('mgr-single','127.0.0.1',23224,null,80); SELECT asynchronous_connection_failover_add_source('mgr-single','127.0.0.1',23225,null,50);startslaveforchannel'mgr-single';
2. 在從機上建立指向 MGR 主節點的復制通道，
3. 在從機上配置 asynchronous connection auto failover
4. 檢查非同步復制通道是否啟用 failover。
mysql> SELECT CHANNEL_NAME, SOURCE_CONNECTION_AUTO_FAILOVER FROM performance_schema.replication_connection_configuration; +--------------+---------------------------------+| CHANNEL_NAME | SOURCE_CONNECTION_AUTO_FAILOVER |+--------------+---------------------------------+|mgr-single |1|+--------------+---------------------------------+1 row in set (0.01 sec
5. 把 MGR 的 primary 節點 kill 掉，這個從節點會在嘗試幾輪重連失敗後自動切換到次權重的復制源，其日誌中會輸出切換信息。
注意：當主節點故障，一旦復制鏈路成功 failover 後，在新的復制鏈路沒有故障時，如果原主節點恢復，是不會回切的。如果當前復制鏈路發生故障，會再次選擇權重高的進行切換
C. 前端開發中如何實現非同步編程
非同步編程其實很常見，特別是在出線Node.js之後，非同步編程更是讓很多開發者受益。那麼回到最初的地方，傳統的前端開發中如何實現非同步編程呢？下面列舉了js實現非同步編程的四種方式。
方法一：使用回調函數
方法二：事件監聽
可以定義一個事件，並為這個事件設定處理函數。這樣只有當這個時間發生的情況下，對應的處理函數才會被執行。
方法三：事件的發布/訂閱
這個模式在NodeJS以及其他JS框架中都有實現，是一個非常常用的非同步編程方式。具體的原理及實現方法可以參考我之前的博客：http://blog.csdn.net/fareise/article/details/52198877《 Node中EventEmitter以及如何實現JavaScript中的訂閱/發布模式》，裡面有比較詳細的解析。
方法四：Promise模式
ES6中提供了原生的Promise對象，這個模式最開始只是一個構想，後來由一些框架庫實現。Promise對象代表了未來才會知道結果的事件。
Promise的基本思路就是，將需要非同步執行的事件儲存起來，然後根據非同步事件之行後的結果狀態執行下一步的操作。具體的Promise對象的原理和ES6中的使用方法將在下一篇文章中更加深入的進行介紹。
D. 什麼是非同步編程
傳統的同步編程是一種請求響應模型，調用一個方法，等待其響應返回.
非同步編程就是要重新考慮是否需要響應的問題，也就是縮小需要響應的地方。因為越快獲得響應，就是越同步化，順序化，事務化，性能差化。
非同步編程通常是通過fire and forget方式實現，發射事件後即忘記，做別的事情了，無需立即等待剛才發射的響應結果了。(發射事件的地方稱為生產者，而將在另外一個地方響應事件的處理者稱為消費者).非同步編程是一種事件驅動編程，需要完全改變思路，將「請求響應」的思路轉變到「事件驅動」思路上，是一種軟體編程思維的轉變.下面幾種你看參考一下
1、非同步編程模型 (APM) 模式（也稱為 IAsyncResult 模式），其中非同步操作要求 Begin 和 End 方法（例如，非同步寫操作的 BeginWrite 和 EndWrite）。對於新的開發工作不再建議採用此模式。
2、基於事件的非同步模式 (EAP) 需要一個具有 Async 後綴的方法，還需要一個或多個事件、事件處理程序、委託類型和 EventArg 派生的類型。EAP 是在 .NET Framework 2.0 版中引入的。對於新的開發工作不再建議採用此模式。
3、基於任務的非同步模式 (TAP)，該模式使用一個方法表示非同步操作的啟動和完成。.NET Framework 4 中引入了 TAP，並且是 .NET Framework 中非同步編程的建議方法。
E. C#幾種非同步編程
1、非同步編程模型 (APM) 模式（也稱為 IAsyncResult 模式），其中非同步操作要求 Begin 和 End 方法（例如，非同步寫操作的 BeginWrite 和 EndWrite）。對於新的開發工作不再建議採用此模式。
2、基於事件的非同步模式 (EAP) 需要一個具有 Async 後綴的方法，還需要一個或多個事件、事件處理程序、委託類型和 EventArg 派生的類型。EAP 是在 .NET Framework 2.0 版中引入的。對於新的開發工作不再建議採用此模式。
3、基於任務的非同步模式 (TAP)，該模式使用一個方法表示非同步操作的啟動和完成。.NET Framework 4 中引入了 TAP，並且是 .NET Framework 中非同步編程的建議方
F. 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測試成功。
G. 什麼是同步編程、非同步編程
同步編程：傳統的同步編程是一種請求響應模型，調用一個方法，等待其響應返回。就是一個線程獲得了一個任務，然後去執行這個任務， 當這個任務執行完畢後，才能執行接下來的另外一個任務。
非同步編程：非同步編程就是要重新考慮是否需要響應的問題，也就是縮小需要響應的地方。因為越快獲得響應，就是越同步化，順序化，事務化，性能差化，非同步編程通常是通過fire and forget方式實現。
(7)非同步編程擴展閱讀：
在同步編程中，所有的操作都是順序執行的，比如從socket中讀取（請求），然後寫入（回應）到socket中，每一個操作都是阻塞的。
非同步編程的原則是，讓進程處理多個並發執行的上下文來模擬並行處理方式 ，非同步應用使用一個事件循環，當一個事件觸發暫停或恢復執行上下文：
只有一個上下文處於活動狀態，上下文之間進行輪替，代碼中的顯示指令告訴事件循環，哪裡可以暫停執行，這時，進程將查找其他待處理的線程進行恢復，最終，進程將回到函數暫停的地方繼續運行，從一個執行上下文移到另一個上下文稱為切換。
H. 非同步編程的應用：什麼情況下會用到非同步編程
如果數據將在線程間共享。例如正在寫的數據以後可能被另一個線程讀到，或者正在讀的數據可能已經被另一個線程寫過了，那麼這些數據就是共享數據，必須進行同步存取。當應用程序在對象上調用了一個需要花費很長時間來執行的方法，並且不希望讓程序等待方法的返回時，就應該使用非同步編程，在很多情況下採用非同步途徑往往更有效率。
I. JS非同步編程該怎麼寫更優雅
var ajax1 = $.ajax(url);
var ajax2 = $.ajax(url);
var ajax3 = $.ajax(url);
$.when(
ajax1, ajax2, ajax3
).then(function(data){
console.log(data);
clearPassword();
});
J. 關於generator非同步編程的理解以及如何動手寫
關於generator非同步編程的理解以及如何動手寫一個co模塊
generator出現之前，想要實現對非同步隊列中任務的流程式控制制，大概有這么一下幾種方式：
回調函數
事件監聽
發布/訂閱
promise對象
第一種方式想必大家是最常見的，其代碼組織方式如下：
我們把函數放到run的執行器裡面，便實現了同步操作非同步代碼的過程