[转载] 同步和异步的区别

1.
举个例子：普通B/S模式（同步）AJAX技术（异步）
同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事
异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕
-----------------------------------------------------------------------------------
同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。
异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。
所以，要我请你吃饭就用同步的方法，要请我吃饭就用异步的方法，这样你可以省钱。
------------------------------------------------------------------------------------
举个例子 打电话时同步 发消息是异步

2.
经常看到介绍 ArrayList 和HashMap是异步，Vector和HashTable是同步,这里同步是线程安全的，异步不是线程安全的，举例说明:
当创建一个Vector对象时候，
Vector ve=new Vector();
ve.add("1");
当在多线程程序中，第一个线程调用修改对象ve的时候，就为其上了锁，其他线程只有等待。
当创建一个ArrayList对象时候，
ArrayList list=new ArrayList();
list.add("1");
当在多线程程序中，第一个线程调用修改对象list的时候，没有为其上锁，其他线程访问时就会报错。
eg：list.remove("1"),然后再由其他线程访问list对象的1时就会报错。

3.
如果数据将在线程间共享.例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取.
    当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率.

    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<length;i++) {
    if(数据组[i].mark == 传入的值) (数据组[i].*fn)();
    }
    简单说c/c++中将要被调用的涵数可以被保存起来,然后去访问,调用,而Java中,我们无法将一个方法保存,除了直接调用,所以将要调用的方法用子类来实现,然后把这些子类实例保存起来,然后在这些子类的实现上调用方法:
    interface My{
    void test();
    }
    class A implements My{
    public void test(){
    System.out.println("A"):
    }
    }
    class B implements My{
    public void test(){
    System.out.println("B"):
    }
    }
    class C implements My{
    public void test(){
    System.out.println("C"):
    }
    }
    class MyStruct {
    int mark;
    My m;
    public MyStruct(int mark,My m){this.mark = amrk;this.m = m}
    }
    数组:
    { new MyStruct(1,new A()),new MyStruct(2,new B()),new MyStruct(3,new C())}
    for(xxxxxxxxx) if(参数 ==数组[i].mark) 数组[i].m.test();
    这样把要调用的方法转换为对象的保程不仅仅是可以对要调用的方法进行调度,而且可以把对象序列化后在另一台机器上执行,这样就把调用边界从线程扩展到了机器.
    回到我们的例子:
    class Proxy implements Axman{
    private final Scheduler scheduler;
    private final Servant servant;
    public Proxy(Scheduler scheduler,Servant servant){
    this.scheduler = scheduler;
    this.servant = servant;
    }
    public Result resultTest(int count,char c){
    FutureResult futrue = new FutureResult();
    this.scheduler.invoke(new ResultRequest(servant,futrue,count,c));
    return futrue;
    }
    public void noResultTest(String str){
    this.scheduler.invoke(new NoResultRequest(this.servant,str));
    }
    }
    其中scheduler是管理对调用的调度, servant是真正的对方法的执行:
    Servant就是去真实地实现方法:
    class Servant implements Axman{
    public Result resultTest(int count,char c){
    char[] buf = new char[count];
    for(int i = 0;i < count;i++){
    buf[i] = c;
    try{
    Thread.sleep(100);
    }catch(Throwable t){}
    }
    return new RealResult(new String(buf));
    }
    public void noResultTest(String str){
    try{
    System.out.println("displayString :" + str);
    Thread.sleep(10);
    }catch(Throwable t){}
    }
    }
    在scheduler 将方法的调用(invkoe)和执行(execute)进行了分离,调用就是开始"注册"方法到要执行的容器中,这样就可以立即返回出来.真正执行多久就 是execute的事了,就象一个人点燃爆竹的引信就跑了,至于那个爆竹什么时候爆炸就不是他能控制的了.
    public class Scheduler extends Thread {
    private final ActivationQueue queue;
    public Scheduler(ActivationQueue queue){
    this.queue = queue;
    }
    public void invoke(MethodRequest request){
    this.queue.putRequest(request);
    }
    public void run(){
    while(true){
    //如果队列中有请求线程,测开始执行请求
    MethodRequest request = this.queue.takeRequest();
    request.execute();
    }
    }
    }
    在scheduler中只用一个队列来保存代表方法和请求对象,实行简单的FIFO调用,你要实更复杂的调度就要在这里重新实现:
    class ActivationQueue{
    private static final int MAX_METHOD_REQUEST = 100;
    private final MethodRequest[] requestQueue;
    private int tail;
    private int head;
    private int count;
    public ActivationQueue(){
    this.requestQueue = new MethodRequest[MAX_METHOD_REQUEST];
    this.head = this.count = this.tail = 0;
    }
    public synchronized void putRequest(MethodRequest request){
    while(this.count >= this.requestQueue.length){
    try {
    this.wait();
    }
    catch (Throwable t) {}
    }
    this.requestQueue[this.tail] = request;
    tail = (tail + 1)%this.requestQueue.length;
    count ++ ;
    this.notifyAll();
    }
    public synchronized MethodRequest takeRequest(){
    while(this.count <= 0){
    try {
    this.wait();
    }
    catch (Throwable t) {}
    }
    MethodRequest request = this.requestQueue[this.head];
    this.head = (this.head + 1) % this.requestQueue.length;
    count --;
    this.notifyAll();
    return request;
    }
    }
    为了将方法调用转化为对象,我们通过实现MethodRequest对象的execute方法来方法具体方法转换成具体对象:
    abstract class MethodRequest{
    protected final Servant servant;
    protected final FutureResult future;
    protected MethodRequest(Servant servant,FutureResult future){
    this.servant = servant;
    this.future = future;
    }
    public abstract void execute();
    }
    class ResultRequest extends MethodRequest{
    private final int count;
    private final char c;
    public ResultRequest(Servant servant,FutureResult future,int count,char c){
    super(servant,future);
    this.count = count;
    this.c = c;
    }
    public void execute(){
    Result result = servant.resultTest(this.count,this.c);
    this.future.setResult(result);
    }
    }
    class NoResultRequest extends MethodRequest{
    private String str;
    public NoResultRequest(Servant servant,String str){
    super(servant,null);
    this.str = str;
    }
    public void execute(){
    this.servant.noResultTest(str);
    }
    }
    而返回的数据我们也将真实数据的获取和取货凭证逻辑分离:
    package com.axman.jasync;
    public abstract class Result {
    public abstract Object getResult();
    }
    class FutureResult extends Result{
    private Result result;
    private boolean completed;
    public synchronized void setResult(Result result){
    this.result = result;
    this.completed = true;
    this.notifyAll();
    }
    public synchronized Object getResult(){
    while(!this.completed){
    try{
    this.wait();
    }catch(Throwable t){}
    }
    return this.result.getResult();
    }
    }
    class RealResult extends Result{
    private final Object result;
    public RealResult(Object result){
    this.result = result;
    }
    public Object getResult(){
    return this.result;
    }
    }
    OK,现在这个异步消息处理器已经有了模型,这个异步处理器中有昭雪些对象参与呢?
    Servant 忠心做真实的事务
    ActivationQueue将请求缓存起来以便调度
    Scheduler对容器中的请求根据一定原则进行调度执行
    Proxy将特定方法请求转换为特定对象
    所有这些都是这个异步处理器的核心部件,虽然是核心部件,我们就要进行封装而不能随便让调用者来修改,所以我们用工厂模式(我KAO,我实在不想提模式但有时找不到其它词来表述)来产生处理器Axman对象:
    package com.axman.jasync;
    public class AxmanFactory {
    public static Axman createAxman() {
    Servant s = new Servant();
    ActivationQueue queue = new ActivationQueue();
    Scheduler st = new Scheduler(queue);
    Proxy p = new Proxy(st,s);
    st.start();
    return p;
    }
    }
    好了,我们现在用两个请求的产生者不停产生请求:
    ResultInvokeThreadv 发送有返回值的请求:
    package com.axman.jasync;
    public class ResultInvokeThread extends Thread{
    private final Axman ao;
    private final char c;
    public ResultInvokeThread(String name,Axman ao){
    this.ao = ao;
    this.c = name.charAt(0);
    }
    public void run(){
    try{
    int i = 0;
    while(true){
    Result result = this.ao.resultTest(i++,c);
    Thread.sleep(10);
    String = (String)result.getResult();
    System.out.println(Thread.currentThread().getName() + " = " + );
    }
    }
    catch(Throwable t){}
    }
    }
    NoResultInvokeThread发送无返回值的请求:
    package com.axman.jasync;
    public class NoResultInvokeThread extends Thread{
    private final Axman ao;
    public NoResultInvokeThread(String name,Axman ao){
    super(name);
    this.ao = ao;
    }
    public void run(){
    try{
    int i = 0;
    while(true){
    String s = Thread.currentThread().getName() + i++;
    ao.noResultTest(s);
    Thread.sleep(20);
    }
    }
    catch(Throwable t){}
    }
    }
    对了,我们还需要一个什么东西来产生一个演示:
    package com.axman.jasync;
    public class Program {
    public static void main(String[] args) {
    Axman ao = AxmanFactory.createAxman();
    new ResultInvokeThread("Axman",ao).start();
    new ResultInvokeThread("Sager",ao).start();
    new NoResultInvokeThread("Macke",ao).start();
    }
    }
    看看结果吧.你可以把不同类型的请求不断地向处理器发送,处理器会不断地接收请求,放到队列中,并同时不断从队列中提出请求进行处理.