精华内容
下载资源
问答
  • android 网络请求使用的异步请求, 为啥不用同步呢 假如改成同步了, 要等所有的操作完成之后才会通知用户操作完成,假如主线程在这个期间等待超过了5s android 这边会提示 anr 应用程序无响应. 所以我们选...

    同步: 所有操作完成之后,才会通知用户操作完成了.

    异步:不用等所有操作完成之后,就会通知用户操作完成了,然后后台会继续操作直到完成结束.

    为了方便理解 举例个常见的

    android 网络请求使用的异步请求, 为啥不用同步呢 

    假如改成同步了, 要等所有的操作完成之后才会通知用户操作完成,假如主线程在这个期间等待超过了5s

    android 这边会提示 anr 应用程序无响应. 所以我们选择了异步请求....

    这是自己的理解

    网上别人举得例子:

    举个例子:普通B/S模式(同步)AJAX技术(异步)
    同步:提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事

    异步: 请求通过事件触发->服务器处理(这是浏览器仍然可以作其他事情)->处理完毕

     

    同步线程与异步线程

    线程同步:是多个线程同时访问同一资源,等待资源访问结束,浪费时间,效率低   

    线程异步:访问资源时在空闲等待时同时访问其他资源,实现多线程机制

     

     

    展开全文
  • AB之间是同步调用 BC是异步调用 现在需要A同步请求B时 B根据A的请求去异步请求C A等待 B要等到C异步返回数据之后 在将C返回的数据同步返回给A 。 有没有好的解决方案 。 感谢各位大神给我解答一下。
  • JAVA异步和同步区别

    千次阅读 2017-12-24 21:29:15
     区别:一个需要等待,一个不需要等待,在部分情况下,我们的项目开发中都会优先选择不需要等待的异步交互方式。 打个比方: 早晨送牛奶的大叔,每天都会把牛奶送到你家,有时候你家有人直接送进去,有时候没人他...

    同步:指发送一个请求,需要等待返回,然后才能够发送下一个请求,有个等待过程;

    异步:指发送一个请求,不需要等待返回,随时可以再发送下一个请求,即不需要等待。

     区别:一个需要等待,一个不需要等待,在部分情况下,我们的项目开发中都会优先选择不需要等待的异步交互方式。

    打个比方:

    早晨送牛奶的大叔,每天都会把牛奶送到你家,有时候你家有人直接送进去,有时候没人他会放在门口的那个牛奶盒子里面,然后去下一家,这个就和异步一样的性质

    而同步就好比 ——你要回家,你没带钥匙,你家没人,敲门没人开门,那么你只有等家人回来了在进门,总不能去别人家吧。

    这就是同步和异步的区别。

    展开全文
  • 主要介绍了Java异步调用转同步方法实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java中关于同步和异步区别:  同步,是请求完成之后,需要等待服务的响应之后,才能进行下一次请求;一般应用于需要及时返回结果的业务上;  异步,是请求完成之后不需要等待响应,就可以进行下一次请求。


    Java中关于同步和异步的区别:

        同步,是请求完成之后,需要等待服务的响应之后,才能进行下一次请求;一般应用于需要及时返回结果的业务上;

        异步,是请求完成之后不需要等待响应,就可以进行下一次请求。

    展开全文
  • 先来说一下对异步和同步的理解: 同步调用:调用方在调用过程中,持续等待返回结果。异步调用:调用方在调用过程中,不直接等待返回结果,而是执行其他任务,结果返回形式通常为回调函数。 其实,两者的区别还是...

    前言

    先来说一下对异步和同步的理解:

    同步调用:调用方在调用过程中,持续等待返回结果。
    异步调用:调用方在调用过程中,不直接等待返回结果,而是执行其他任务,结果返回形式通常为回调函数。

    其实,两者的区别还是很明显的,这里也不再细说,

    我们主要来说一下 Java 如何将异步调用转为同步。换句话说,就是需要在异步调用过程中,持续阻塞至获得调用结果。
    不卖关子,先列出五种方法,然后一一举例说明:

    1. 使用 wait 和 notify 方法
    2. 使用条件锁
    3. Future
    4. 使用 CountDownLatch
    5. 使用 CyclicBarrier

    构造一个异步调用

    首先,写 demo 需要先写基础设施,这里的话主要是需要构造一个异步调用模型。异步调用类:

    AsyncCall.java

    package AsyncCalltoSynchro;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    //异步调用类
    public class AsyncCall {
        //生成随机数
        private Random random = new Random(System.currentTimeMillis());
        //执行器
        private ExecutorService tp = Executors.newSingleThreadExecutor();
    
        //demo1,2,4,5调用方法
        public void call(BaseDemo demo){
    
            //开启线程
            new Thread(()->{
                //0-10随机数
                long res = random.nextInt(10);
    
                try {
                    Thread.sleep(res*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                //异步调用
                demo.callback(res);
            }).start();
    
    
        }
    
        //demo3调用方法
        public Future<Long> futureCall(){
    
            return tp.submit(()-> {
                long res = random.nextInt(10);
    
                try {
                    Thread.sleep(res*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return res;
            });
    
        }
    
        //关闭线程池
        public void shutdown(){
    
            tp.shutdown();
    
        }
    
    }

    我们主要关心 call( ) 方法,这个方法接收了一个 demo 参数,并且开启了一个线程,在线程中执行具体的任务,并利用 demo callback( ) 方法进行回调函数的调用。大家注意到了这里的返回结果就是一个 [0,10) 的长整型,并且结果是几,就让线程 sleep 多久 —— 这主要是为了更好地观察实验结果,模拟异步调用过程中的处理时间。
    至于 futureCall( ) shutdown( ) 方法,以及线程池 tp 都是为了 demo3 利用 Future 来实现做准备的。
    demo 的基类: BaseDemo.java

    package AsyncCalltoSynchro;
    
    public abstract class BaseDemo {
    
        //异步调用类实例
        protected AsyncCall asyncCall = new AsyncCall();
    
        //抽象
        public abstract void callback(long response);
    
        //发起异步调用
        public void call(){
            System.out.println("发起调用");
            asyncCall.call(this);
            System.out.println("调用返回");
        }
    
    }
    

    BaseDemo 非常简单,里面包含一个异步调用类的实例,另外有一个 call( ) 方法用于发起异步调用,当然还有一个抽象方法 callback( ) 需要每个 demo 去实现的 —— 主要在回调中进行相应的处理来达到异步调用转同步的目的。

     使用 wait 和 notify 方法

    这个方法其实是利用了锁机制,直接贴代码:

    package AsyncCalltoSynchro;
    
    /**
     * 锁机制
     */
    public class Demo1 extends BaseDemo {
    
        private final Object lock = new Object();
    
        @Override
        public void callback(long response) {
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            synchronized (lock) {
                //唤醒正在等待的所有线程
                lock.notifyAll();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo1 demo1 = new Demo1();
    
            demo1.call();
    
            synchronized (demo1.lock){
                try {
                    demo1.lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("主线程内容");
    
        }
    }

    可以看到在发起调用后,主线程利用 wait( ) 进行阻塞,等待回调中调用 notify( ) 或者 notifyAll( ) 方法来进行唤醒。注意,和大家认知的一样,这里 wait( ) notify( ) 都是需要先获得对象的锁的。在主线程中最后我们打印了一个内容,这也是用来验证实验结果的,如果没有 wait( ) notify( ),主线程内容会紧随调用内容立刻打印;而像我们上面的代码,主线程内容会一直等待回调函数调用结束才会进行打印。
    没有使用同步操作的情况下,打印结果:

    而使用了同步操作后:

    使用条件锁

    和方法一的原理类似:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 条件锁finally
     */
    public class Demo2 extends BaseDemo {
    
        private final Lock lock = new ReentrantLock();
    
        private final Condition con = lock.newCondition();
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            lock.lock();
            
            try {
                //线程唤醒
                con.signal();
            }finally {
                lock.unlock();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo2 demo2 = new Demo2();
    
            demo2.call();
    
            demo2.lock.lock();
    
            try {
                //Causes the current thread to wait until it is signalled or interrupted.
                demo2.con.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                demo2.lock.unlock();
            }
            System.out.println("主线程内容");
        }
    }

    基本上和方法一没什么区别,只是这里使用了条件锁,两者的锁机制有所不同。

    实验结果

    Future

    使用 Future 的方法和之前不太一样,我们调用的异步方法也不一样。

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.Future;
    
    public class Demo3 {
    
        private AsyncCall asyncCall = new AsyncCall();
    
        public Future<Long> call(){
    
            Future<Long> future = asyncCall.futureCall();
    
            asyncCall.shutdown();
    
            return future;
    
        }
    
        public static void main(String[] args) {
    
            Demo3 demo3 = new Demo3();
    
            System.out.println("发起调用");
            Future<Long> future = demo3.call();
            System.out.println("返回结果");
    
            while (!future.isDone() && !future.isCancelled());
    
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    我们调用 futureCall( ) 方法,方法中会想线程池 tp 提交一个 Callable( ),然后返回一个 Future,这个 Future 就是我们 demo3 call 中得到的,得到 future 对象之后就可以关闭线程池啦,调用 asyncCall( ) shutdown( ) 方法。关于关闭线程池这里有一点需要注意,我们回过头来看看 asyncCall( ) shutdown( ) 方法:

        //关闭线程池
        public void shutdown(){
    
            tp.shutdown();
    
        }

    发现只是简单调用了线程池的 shutdown( ) 方法,然后我们说注意的点,这里最好不要用 tp shutdownNow( ) 方法,该方法会试图去中断线程中中正在执行的任务;也就是说,如果使用该方法,有可能我们的 future 所对应的任务将被中断,无法得到执行结果。
    然后我们关注主线程中的内容,主线程的阻塞由我们自己来实现,通过 future isDone( ) isCancelled( ) 来判断执行状态,一直到执行完成或被取消。随后,我们打印 get 到的结果。

    实验结果

    使用 CountDownLatch

    使用 CountDownLatch 或许是日常编程中最常见的一种了,也感觉是 相对优雅 的一种:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.CountDownLatch;
    
    public class Demo4 extends BaseDemo {
    
        private final CountDownLatch countDownLatch = new CountDownLatch(1);
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            countDownLatch.countDown();
    
        }
    
        public static void main(String[] args) {
    
            Demo4 demo4 = new Demo4();
    
            demo4.call();
    
            try {
                demo4.countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    正如大家平时使用的那样,此处在主线程中利用 CountDownLatch await( ) 方法进行阻塞,在回调中利用 countDown( ) 方法来使得其他线程 await 的部分得以继续运行。
    当然,这里和 demo1 demo2 中都一样,主线程中阻塞的部分,都可以设置一个超时时间,超时后可以不再阻塞。

    实验结果

    使用 CyclicBarrier

    CyclicBarrier 的情况和 CountDownLatch 有些类似:

    package AsyncCalltoSynchro;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    public class Demo5 extends BaseDemo {
    
        private CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    
    
        @Override
        public void callback(long response) {
    
            System.out.println("得到结果");
            System.out.println(response);
            System.out.println("调用结束");
    
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
    
        }
    
        public static void main(String[] args) {
    
            Demo5 demo5 = new Demo5();
    
            demo5.call();
    
            try {
                demo5.cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
    
            System.out.println("主线程内容");
    
        }
    }

    实验结果

    大家注意一下,CyclicBarrier CountDownLatch 仅仅只是类似,两者还是有一定区别的。比如,一个可以理解为做加法,等到加到这个数字后一起运行;一个则是减法,减到 0 继续运行。一个是可以重复计数的;另一个不可以等等等等。

    另外,使用 CyclicBarrier 的时候要注意两点:

    • 初始化的时候,参数数字要设为 2,因为异步调用这里是一个线程,而主线程是一个线程,两个线程都 await 的时候才能继续执行,这也是和 CountDownLatch 区别的部分。
    • 第二点也是关于初始化参数的数值的,和这里的 demo 无关,在平时编程的时候,需要比较小心,如果这个数值设置得很大,比线程池中的线程数都大,那么就很容易引起死锁了。

    总结

    综上,就是本次需要说的几种方法了。事实上,所有的方法都是同一个原理,也就是在调用的线程中进行阻塞等待结果,而在回调中函数中进行阻塞状态的解除。

     

    展开全文
  • 1、同步和异步区别和联系  所谓同步,可以理解为在执行完一个函数或方法之后,一直等待系统返回值或消息,这时程序是出于阻塞的,只有接收到  返回的值或消息后才往下执行其它的命令。  异步,执行完函数或...
  • 主要介绍了java同步异步、阻塞非阻塞区别详解的相关资料,需要的朋友可以参考下
  • java 异步 同步应用

    2017-08-26 19:35:34
    一、什么是异步同步 所谓异步输入输出机制,是指在进行输入输出处理时,不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞(None Blocking)。 网上有很多网友用很通俗的比喻 把同步异步讲解的很透彻 转...
  • 网上有很多网友用很通俗的比喻 把同步和异步讲解的很透彻 转过来   举个例子:普通B/S模式(同步)AJAX技术(异步)   同步:提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事   
  • Java中的多线程重点内容异步和同步一、多线程中的同步异步1.多线程中,多个线程同时并发执行;当请求处理同一块资源时(变量,写文件,主机端口占用等),必然导致该资源的数据不安全(或者冲突,无效)。 因此处理...
  • Java中的同步和异步区别 经常看到介绍 ArrayList HashMap是异步,VectorHashTable是同步,这里同步是线程安全的,异步不是线程安全的,举例说明: 当创建一个Vector对象时候, Vector ve=new Vector(); ve.a
  • java异步接口转同步接口 Java已经走了很长一段路。 很长的路要走。 它带有早期设计决策中的所有“垃圾”。 一遍又一遍后悔的一件事是, 每个对象(可能)都包含一个监视器 。 几乎没有必要这样做,并且最终在Java...
  • Java中的异步和同步代码模式 博客文章的示例代码
  • java 异步查询转同步多种实现式循环等待 CountDownLatchSpring EventListener 异步同步 业务需求 思路 循环等待 CountDownLatch Spring EventListener 超时空循环 空循环 超时编写 代码地址 异步同步 业务需求...
  • Java线程的同步和异步区别

    千次阅读 2014-05-20 18:08:12
    1.    多线程并发时,多个线程同时请求同一个资源,必然导致此资源的数据不安全,A线程修改了B线 程的处理的数据,而B线程...系统处理性能,加在多线程并发时资源挣夺最激烈的地方,这就实现了线程的同步机制
  • 主要介绍了Java中的同步异步详细介绍,具有一定参考价值,需要的朋友可以了解下。
  • 主要给大家介绍了关于Java系统中拆分同步和异步的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要介绍了JAVA同步异步、阻塞非阻塞之间的区别,文中讲解非常细致,帮助大家更好的理解学习,感兴趣的朋友可以了解下
  • java同步和异步

    2017-07-14 22:44:44
    java同步和异步有什么异同? 同步交互:指发送一个请求,需要等待返回,然后才能够发送下一个请求,有个等待过程; 异步交互:指发送一个请求,不需要等待返回,随时可以再发送下一个请求,即不...
  • Java 异步方法转同步

    万次阅读 2013-12-04 17:38:32
    Java 异步方法转同步 有一些api提供的方法是异步的,这类的方法大概类型如下: private void asyMethod( String param,RequestCallback callback); 闭锁是一种同步工具类,可以延迟线程的进度知道达到其终止状态[CPJ...
  • java 异步机制与同步机制的区别

    千次阅读 2016-05-06 23:39:51
    原文:http://blog.itpub.net/17074730/viewspace-563262所谓异步输入输出机制...网上有很多网友用很通俗的比喻 把同步和异步讲解的很透彻 转过来举个例子:普通B/S模式(同步)AJAX技术(异步同步:提交请求->等
  • Java 同步和异步

    2019-09-30 13:00:29
    同步:发送一个请求,等待返回,然后再发送下一个请求 异步:发送一个请求,不等待返回,随时可以再发送下一个请求 同步可以避免出现死锁,读脏数据的发生,一般共享某一资源的时候用,如果每个人都有修改权限,同时修改一...
  • java 同步和异步

    2019-09-03 18:42:19
    同步是代码运行时必须等待响应结果之后才能继续运行。 异步是可以不用等待响应结果,继续运行
  • Java 多线程同步和异步详解

    千次阅读 2018-05-31 10:00:32
    转载自 https://www.cnblogs.com/mengyuxin/p/5358364.htmljava线程 同步异步 线程池1)多线程并发时,多个线程同时请求同一个资源,必然导致此资源的数据不安全,A线程修改了B线程的处理的数据,而B线程又修改了...
  • 而我们牛气冲冲的Java自然也有同步异步,不过Java中的同步异步似乎与我们平常认知中的同步异步有些区别。 到底是什么呢? 今天我们就来了解一下Java同步异步有什么区别。 1.同步 在多线程的环境中,经常...
  • java线程同步异步 多线程并发时,多个线程同时请求同一个资源,必然导致此资源的数据不安全,A线程修改了B线程的处理的数据,而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的,有时为了解决此问题,...
  • 主要介绍了java 同步异步、阻塞非阻塞分析的相关资料,需要的朋友可以参考下
  • 欢迎点击「算法与编程之美」↑关注我们!本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。问题描述同步传输和异步传输是web数据库的重要知识点,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,184
精华内容 81,673
关键字:

java异步和同步的区别

java 订阅