java面试笔试题:同步和异步有何异同

所谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。
 
网上有很多网友用很通俗的比喻  把同步和异步讲解的很透彻 转过来
 
举个例子：普通B/S模式（同步）AJAX技术（异步） 
          同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事 
          异步:  请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕
 
同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。 
异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。 
所以，要我请你吃饭就用同步的方法，要请我吃饭就用异步的方法，这样你可以省钱。
 
 
以通讯为例 
          同步:发送一个请求,等待返回,然后再发送下一个请求 
          异步:发送一个请求,不等待返回,随时可以再发送下一个请求 
          并发:同时发送多个请求
 
 
 
下面再转一段关于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个通道一起注册使用。
 
           应用实例：
    下面是用异步输入输出机制实现的客户/服务器实例程序�D�D程序清单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.hasNext()) {
                SelectionKey key = (SelectionKey)i.next();
                i.remove();//删除当前将要处理的选择键
                if ( key.isAcceptable() ) {//如果是有客户端连接请求
                    System.out.println("more client connect in!");
                    ServerSocketChannel nextReady =
                        (ServerSocketChannel)key.channel();
                    //获取客户端套接字
                    Socket s = nextReady.accept();
                    //设置对应的通道为异步方式并注册感兴趣事件
                    s.getChannel().configureBlocking( false );
                    SelectionKey readWriteKey =
                        s.getChannel().register( this.selector,
                            SelectionKey.OP_READ|SelectionKey.OP_WRITE  );
                    //将注册的事件与该套接字联系起来
readWriteKey.attach( s );
//将当前建立连接的客户端套接字及对应的通道存放在哈希表//clientChannelMap中
                    this.clientChannelMap.put( s, new 
ClientChInstance( s.getChannel() ) );
                    }
                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();
        }
    }
}
 
小结：
从以上程序段可以看出，服务器端没有引入多余线程就完成了多客户的客户/服务器模式。该程序中使用了回调模式(CALLBACK)，细心的读者应该早就看出来了。需要注意的是，请不要将原来的输入输出包与新加入的输入输出包混用，因为出于一些原因的考虑，这两个包并不兼容。即使用通道时请使用缓冲完成输入输出控制。该程序在Windows2000,J2SE1.4下，用telnet测试成功。

--------------------------------------分-------------------割---------------------------线--------------------------------------------------

如果数据将在线程间共享.例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取.     当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率.       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异步:     一.    它要能适应不同类型的请求:     本节用 makeString来说明要求有返回值的请求.用displayString来说明不需要返回值的请求.     二.    要能同时并发处理多个请求,并能按一定机制调度:     本节将用一个队列来存放请求,所以只能按FIFO机制调度,你可以改用LinkedList,就可以简单实现一个优先级(优先级高的addFirst,低的addLast).     三.    有能力将调用的边界从线程扩展到机器间(RMI)     四.    分离过度耦合,如分离调用句柄(取货凭证)和真实数据的实现.分离调用和执行的过程,可以尽快地将调返回.     现在看具体的实现:     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     if(数据组[i].mark == 传入的值) (数据组[i].*fn)();     }     简单说c/c++中将要被调用的涵数可以被保存起来,然后去访问,调用,而Java中,我们无法将一个方法保存,除了直接调用,所以将要调用的方法用子类来实现,然后把这些子类实例保存起来,然后在这些子类的实现上调用方法:     interface My{     void test();     }

--------------------------------------分-------------------割---------------------------线--------------------------------------------------

同步与异步传输的区别

同步与异步传输的区别.txt6宽容润滑了彼此的关系，消除了彼此的隔阂，扫清了彼此的顾忌，增进了彼此的了解。

在网络通信过程中，通信双方要交换数据，需要高度的协同工作。为了正确的解释信号，接收方必须确切地知道信号应当何时接收和处理，因此定时是至关重要的。在计算机网络中，定时的因素称为位同步。同步是要接收方按照发送方发送的每个位的起止时刻和速率来接收数据，否则会产生误差。通常可以采用同步或异步的传输方式对位进行同步处理。

 

1. 异步传输（Asynchronous Transmission）：异步传输将比特分成小组进行传送，小组可以是8位的1个字符或更长。发送方可以在任何时刻发送这些比特组，而接收方从不知道它们会在什么时候到达。一个常见的例子是计算机键盘与主机的通信。按下一个字母键、数字键或特殊字符键，就发送一个8比特位的ASCII代码。键盘可以在任何时刻发送代码，这取决于用户的输入速度，内部的硬件必须能够在任何时刻接收一个键入的字符。

 

异步传输存在一个潜在的问题，即接收方并不知道数据会在什么时候到达。在它检测到数据并做出响应之前，第一个比特已经过去了。这就像有人出乎意料地从后面走上来跟你说话，而你没来得及反应过来，漏掉了最前面的几个词。因此，每次异步传输的信息都以一个起始位开头，它通知接收方数据已经到达了，这就给了接收方响应、接收和缓存数据比特的时间；在传输结束时，一个停止位表示该次传输信息的终止。按照惯例，空闲（没有传送数据）的线路实际携带着一个代表二进制1的信号，异步传输的开始位使信号变成0，其他的比特位使信号随传输的数据信息而变化。最后，停止位使信号重新变回1，该信号一直保持到下一个开始位到达。例如在键盘上数字“1”，按照8比特位的扩展ASCII编码，将发送“00110001”，同时需要在8比特位的前面加一个起始位，后面一个停止位。

 

异步传输的实现比较容易，由于每个信息都加上了“同步”信息，因此计时的漂移不会产生大的积累，但却产生了较多的开销。在上面的例子，每8个比特要多传送两个比特，总的传输负载就增加25%。对于数据传输量很小的低速设备来说问题不大，但对于那些数据传输量很大的高速设备来说，25%的负载增值就相当严重了。因此，异步传输常用于低速设备。

 

2. 同步传输（Synchronous Transmission）：同步传输的比特分组要大得多。它不是独立地发送每个字符，每个字符都有自己的开始位和停止位，而是把它们组合起来一起发送。我们将这些组合称为数据帧，或简称为帧。

 

数据帧的第一部分包含一组同步字符，它是一个独特的比特组合，类似于前面提到的起始位，用于通知接收方一个帧已经到达，但它同时还能确保接收方的采样速度和比特的到达速度保持一致，使收发双方进入同步。

 

帧的最后一部分是一个帧结束标记。与同步字符一样，它也是一个独特的比特串，类似于前面提到的停止位，用于表示在下一帧开始之前没有别的即将到达的数据了。

 

同步传输通常要比异步传输快速得多。接收方不必对每个字符进行开始和停止的操作。一旦检测到帧同步字符，它就在接下来的数据到达时接收它们。另外，同步传输的开销也比较少。例如，一个典型的帧可能有500字节（即4000比特）的数据，其中可能只包含100比特的开销。这时，增加的比特位使传输的比特总数增加2.5%，这与异步传输中25 %的增值要小得多。随着数据帧中实际数据比特位的增加，开销比特所占的百分比将相应地减少。但是，数据比特位越长，缓存数据所需要的缓冲区也越大，这就限制了一个帧的大小。另外，帧越大，它占据传输媒体的连续时间也越长。在极端的情况下，这将导致其他用户等得太久。

 

 

同步传输方式中发送方和接收方的时钟是统一的、字符与字符间的传输是同步无间隔的。

 

异步传输方式并不要求发送方和接收方的时钟完全一样，字符与字符间的传输是异步的。

 

同步与异步传输的区别

 

1,异步传输是面向字符的传输，而同步传输是面向比特的传输。

 

2,异步传输的单位是字符而同步传输的单位是桢。

 

3,异步传输通过字符起止的开始和停止码抓住再同步的机会，而同步传输则是以数据中抽取同步信息。

 

4,异步传输对时序的要求较低，同步传输往往通过特定的时钟线路协调时序。

 

5,异步传输相对于同步传输效率较低。