精华内容
下载资源
问答
  • Java多线程异步处理

    2020-08-10 10:41:58
    Java多线程异步处理 注意:如下方式会使@Async失效 异步方法使用static修饰 异步类没有使用@Component注解(或其他注解)导致spring无法扫描到异步类 异步方法不能与调用异步方法方法在同一个类中 类中需要使用@...

    Java多线程异步处理

    注意:如下方式会使@Async失效

    • 异步方法使用static修饰
    • 异步类没有使用@Component注解(或其他注解)导致spring无法扫描到异步类
    • 异步方法不能与调用异步方法的方法在同一个类中
    • 类中需要使用@Autowired或@Resource等注解自动注入,不能自己手动new对象
    • 如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解
    • 在Async 方法上标注@Transactional是没用的。 在Async 方法调用的方法上标注@Transactional 有效。
    展开全文
  • PHP多线程异步处理的几种方法

    千次阅读 2018-07-23 10:38:32
    hp 异步调用方法 客户端与服务器端是通过HTTP协议进行连接通讯,客户端发起请求,服务器端接收到请求后执行处理,并返回处理结果。 有时服务器需要执行很耗时的操作,这个操作的结果并不需要返回给客户端。但因为...

    hp 异步调用方法

    客户端与服务器端是通过HTTP协议进行连接通讯,客户端发起请求,服务器端接收到请求后执行处理,并返回处理结果。
    有时服务器需要执行很耗时的操作,这个操作的结果并不需要返回给客户端。但因为php是同步执行的,所以客户端需要等待服务处理完才可以进行下一步。

    因此对于耗时的操作适合异步执行,服务器接收到请求后,处理完客户端需要的数据就返回,再异步在服务器执行耗时的操作。

    1.使用Ajax 与 img 标记
    原理,服务器返回的html中插入Ajax 代码或 img 标记,img的src为需要执行的程序。
    优点:实现简单,服务端无需执行任何调用
    缺点:在执行期间,浏览器会一直处于loading状态,因此这种方法并不算真正的异步调用。

    $.get("doRequest.php", { name: "fdipzone"} );
    <img src="doRequest.php?name=fdipzone">

    2.使用popen
    使用popen执行命令:
    优点:执行速度快
    缺点:1.只能在本机执行
    2.不能传递大量参数
    3.访问量高时会创建很多进程。

    // popen — 打开进程文件指针

    resource popen ( string $command , string $mode )
    pclose(popen('php /home/fdipzone/doRequest.php &', 'r'));

    3.使用curl
    设置curl的超时时间 CURLOPT_TIMEOUT 为1 (最小为1),因此客户端需要等待1秒

    <?php
    $ch = curl_init();
    $curl_opt = array(
        CURLOPT_URL, 'http://www.example.com/doRequest.php'
        CURLOPT_RETURNTRANSFER,1,
        CURLOPT_TIMEOUT,1
    );
    curl_setopt_array($ch, $curl_opt);
    curl_exec($ch);
    curl_close($ch);
    ?>

    4.使用fsockopen
    fsockopen是最好的,缺点是需要自己拼接header部分。

    <?php
    
    $url = 'http://www.example.com/doRequest.php';
    $param = array(
        'name'=>'fdipzone',
        'gender'=>'male',
        'age'=>30
    );
    
    doRequest($url, $param);
    
    function doRequest($url, $param=array()){
    
        $urlinfo = parse_url($url);
    
        $host = $urlinfo['host'];
        $path = $urlinfo['path'];
        $query = isset($param)? http_build_query($param) : '';
    
        $port = 80;
        $errno = 0;
        $errstr = '';
        $timeout = 10;
    
        $fp = fsockopen($host, $port, $errno, $errstr, $timeout);
    
        $out = "POST ".$path." HTTP/1.1\r\n";
        $out .= "host:".$host."\r\n";
        $out .= "content-length:".strlen($query)."\r\n";
        $out .= "content-type:application/x-www-form-urlencoded\r\n";
        $out .= "connection:close\r\n\r\n";
        $out .= $query;
    
        fputs($fp, $out);
        fclose($fp);
    }
    
    ?>
    展开全文
  • 在要异步方法上加上@Async注解, SpringBoot创建了一个名为applicationTaskExecutor的线程池,使用这里面的线程来执行异步调用。 既然默认使用的是SpringBoot自己创建的applicationTaskExecutor,那如何自己去定义...

    启动类上加上注解@EnableAsync开启异步,
    在要异步的方法上加上@Async注解,
    SpringBoot创建了一个名为applicationTaskExecutor的线程池,使用这里面的线程来执行异步调用。
    既然默认使用的是SpringBoot自己创建的applicationTaskExecutor,那如何自己去定义一个线程池呢?

    详情访问
    原址https://blog.csdn.net/qq_33591903/article/details/108486201

    展开全文
  • 下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。 具体思路打个比方来说明一下: 代码噼里啪啦的一顿敲,终于把需求实现了。 现在想休息几分钟,但公司比较抠,只能让你休息三分钟,三分钟后...

    分布式事务介绍:https://zhuanlan.zhihu.com/p/183753774

    前言:项目中在保证数据一致性的前提下还想提高执行效率,有什么好办法么?使用多线程肯定是首先想到的,但多线程之间的事务怎么保持一致呢?下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.support.DefaultTransactionDefinition;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.function.Supplier;
    
    /**
     * 多线程异步处理时的事务管理
     * 1.addFunction 添加要异步执行的方法
     * 2.execute方法中,使用全局的计数器和异常标记字段,统计个异步线程执行的结果
     *      当所有异步线程执行完之后,根据异常标记字段判断是回滚还是提交事务。
     */
    public class MultiThreadTransactionComponent {
        Logger logger= LoggerFactory.getLogger(this.getClass());
    
        private PlatformTransactionManager platformTransactionManager;
        private ThreadPoolExecutor threadPoolExecutor;
    
        private List<Supplier> supplierList=new ArrayList();
        // 创建执行计数器
        private CountDownLatch countDownLatch;
        // 是否存在异常
        AtomicReference<Boolean> isError = new AtomicReference<>(false);
    
        public MultiThreadTransactionComponent(PlatformTransactionManager transactionManager,ThreadPoolExecutor threadPoolExecutor){
            this.platformTransactionManager=transactionManager;
            this.threadPoolExecutor=threadPoolExecutor;
        }
    
        /**
         * 添加要异步执行的方法程序
         * @param supplier
         */
        public void addFunction(Supplier supplier){
            supplierList.add(supplier);
        }
    
        public void execute(){
            countDownLatch=new CountDownLatch(supplierList.size());
            logger.info("【多线程事务】开始...");
            for(Supplier supplier:supplierList){
                this.threadPoolExecutor.submit(new TransactionRunnable(platformTransactionManager,supplier));
            }
            try {
                countDownLatch.await();
                if(isError.get()) {
                    logger.error("【多线程事务】多线程执行失败,事务已回滚");
                    // 主线程抛出自定义的异常
                    throw new RuntimeException("多线程执行失败");
                }
                logger.info("【多线程事务】多线程执行完成,事务已提交");
            } catch (InterruptedException e) {
                logger.error("多线程执行失败");
                // 主线程抛出自定义的异常
                throw new RuntimeException("多线程执行失败"+e.getMessage());
            }
        }
    
    
        class TransactionRunnable implements Runnable{
    
            private PlatformTransactionManager platformTransactionManager;
            private Supplier supplier;
    
            public TransactionRunnable(PlatformTransactionManager platformTransactionManager, Supplier supplier) {
                this.platformTransactionManager=platformTransactionManager;
                this.supplier=supplier;
            }
    
            @Override
            public void run() {
                DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                TransactionStatus transaction = this.platformTransactionManager.getTransaction(def);
                try {
                    this.supplier.get();
                } catch (Exception e) {
                    //设置错误标记
                    isError.set(true);
                    logger.error("【多线程事务】执行失败{}",e.getMessage());
                }
                countDownLatch.countDown();
                try{
                    countDownLatch.await();
                    if(isError.get()){
    //                    logger.info("【多线程事务-子线程】事务回滚");
                        //事务回滚
                        platformTransactionManager.rollback(transaction);
                    }else {
    //                    logger.info("【多线程事务-子线程】事务提交");
                        //事务提交
                        platformTransactionManager.commit(transaction);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    
    }
    

    使用示例:

        @Autowired
        PlatformTransactionManager platformTransactionManager;
        @Autowired
        private ThreadPoolExecutor threadPoolExecutor;
        @Test
        public void testTransaction(){
            MultiThreadTransactionComponent mttc = new MultiThreadTransactionComponent(platformTransactionManager,threadPoolExecutor);
            for(int k=0;k<10;k++){
                int i = RandomUtils.nextInt(0, 5);
                int y=RandomUtils.nextInt(0,5);
                //添加要执行的业务代码
                mttc.addFunction(()->{
                    System.out.println("当前线程:" + Thread.currentThread().getName());
                    System.out.println(i%y);  //除数为0时 执行失败
                    MarketGeomUpLog marketGeomUpLog=new MarketGeomUpLog();
                    marketGeomUpLog.setContent(i+"--"+y);
                    marketGeomUpLogMapper.addLog(marketGeomUpLog);
                    return 0;
                });
            }
            mttc.execute();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    展开全文
  • java中实现多线程 1)继承Thread,重写里面的run方法 2)实现runnable接口通过源码发现:第一种方法说是继承Tread然后重写run方法,通过查看run方法的源码,发现run方法里面调用是runnable接口中抽象的run()方法。...
  • 下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。 import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.transaction.PlatformTransactionManager; import org...
  • 1、我们都知道,Android UI是线程不安全的,如果在子线程中尝试进行UI操作,程序就有可能会崩溃。相信大家在日常的工作当中都会经常遇到这个问题,解决的方案应该也是早已烂熟于心,即创建一个Message对象,然后...
  • AsyncTask抽象出后台线程运行的五个状态,分别是:1、准备运行,2、正在后台运行,3、进度更新,4、完成后台任务,5、取消任务,对于 这五个阶段,AsyncTask提供了五个回调方法: 1、准备运行:onPreExecute(),
  • AsyncTask主要用来更新UI线程,比较耗时的操作可以在AsyncTask中使用。 AsyncTask是个抽象类,使用时需要继承这个类,然后调用execute()方法。注意继承时需要设定三个泛型Params,Progress和Result的类型,如...
  • 2、问题分析 1)究其为啥需要多线程的本质就是异步处理,直观一点说就是不要让用户感觉到“很卡”。 eg:你点击按钮下载一首歌,接着该按钮一直处于按下状态,那么用户体验就很差。 2)多线程实现方式implements ...
  • AsyncTask抽象出后台线程运行的五个状态,分别是:1、准备运行,2、正在后台运行,3、进度更新,4、完成后台任务,5、取消任务,对于 这五个阶段,AsyncTask提供了五个回调方法: 1、准备运行:onPreExecut...
  • 由于Android规定只有UI线程才能更新用户界面和接受用户的按钮及触摸事件,那么就必须保证UI线程不可以被阻塞,从而耗时...Handler用于异步消息处理,在后台线程与UI线程的交互中最常用,Handler自己并不会创建线程...
  •  WinForm的应用程序中如果执行了一个的非常冗长的处理操作,(比如文件检索,大运算量计算),在执行时就会锁定用户界面,虽然...BackgroundWorker 可以用于启动后台线程,并在后台计算结束后调用主线程的方法。 
  • 三种多线程编程方法 1 class Mythread extends Thread{ @Override public void run(){} } new Mythread().start() 2 class Mythread implements Runnable{ @Override ...
  • Java实现多线程异步处理请求: Java实现多线程异步处理请求,即一个服务请求启动一个新线程处理请求,每个服务请求异步处理。 设计如下: Main:程序入口,发起多个服务请求。 Server:服务请求类,接受请求,...
  • 多线程异步编排

    千次阅读 2019-09-06 10:41:33
    异常的处理 加 @FunctionalInterface 才支持lamoda表达式 底层方法: supplyAsync() 异步运行 thenCombine() 合并 thenAccept() 上面执行完触发此方法 get() 同步获取结果 get(long timeout, ...
  • 首先,在之前的基本控件,基本都是在Activity的onCreate(Bundle savedInstanceState)方法中调用和处理的,但是,在有些情况,比如在网络上下载软件等一些需要等待响应时间比较长的操作,如果同样放在Activity的该...
  • 在学习python进程时,进程上运行的方法接收个参数和个结果时遇到了问题,现在经过学习在这里总结一下 Pool.map()参数任务 在给map方法传入带个参数的方法不能达到预期的效果,像下面这样 def job(x ,y): ...
  • 1、在有响应的时候,使用ResponseFuture对象,并在onResponse方法中,将响应设置到Futrue中。 import com.google.common.util.concurrent.AbstractFuture; public classResponseFuture<JsonProtocol> ...
  • 多线程 异步处理 抽象类和接口的区别  abstract可以修饰抽象方法 而一个类只要有一个抽象方法 就必须用abstract定义该类 即抽象类  用interface修饰的类 里面的方法都是抽象方法 因此在定义接口的时候 ...
  • //jdk1.8 ForkJoin是任务的分发处理 private static void getJava8(ExecutorService service) { //默认使用的是ForkJoinPool,如果不传线程池的话 CompletableFuture<Integer> future = CompletableFuture....
  • 织入增强处理都是同步的单一线程,总是在方法返回之前进行。 二、业务场景分析 对一般的业务场景,我们采用aop是可以的。但是如果我们的织入处理很复杂,而且与方法的返回无关。比如复杂日志的记录,这时候我们...
  • 由于一开始是单例模式,导致,在某人查重的时候整个系统是不会再响应别的请求的,导致了系统假死状态,那么我们就应该使用多线程进行处理,将这种不能快速返回结果的方法交给线程池进行处理。...
  • CompletableFuture是java1.8中追加的新功能,在处理java多线程异步时相当的方便,下面是简单的用法 简单的讲述了在非主线程中,执行完一个业务后接着执行另外一个业务的处理方法thenApplyAsync。 import java.util....
  • 上节,我们提到,在异步任务程序中,一种常见的场景是,主线程提交异步任务,然后希望有任务完成就处理结果,并且按任务完成顺序逐个处理,对于这种场景,Java并发包提供了一个方便的方法,使用...
  • 比进程要小很,同时创建一个线程的开销也比进程要小很。 3.线程之间的通信更方便,同一进程下的线程共享全局变量、静态变量等数据,而进程之间的通信需要以通信的方式(IPC)进行。不过如何处理好同步

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,653
精华内容 661
关键字:

多线程异步处理方法