java多线程异步处理

2021-08-21 01:11:41

1、Java多线程实现

A.继承Thread类，重写run方法

@Test
public void threadTest() {
   Thread thread = new myThread();
   thread.start();
}

public class myThread extends Thread {
   @Override
   public void  run(){
       System.out.println("Thread create");
   } 
}

通过继承Thread 重写run方法，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态。

B.实现Runnable接口，重写run方法。

@Test
public void runnableTest() {
   Runnable runnable = new MyRunnable();
   Thread thread = new Thread(runnable);
   thread.start();
}

public class MyRunnable implements Runnable{

   @Override
   public void run() {
       System.out.println("MyRunnable create");
   }
}

创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

C.通过Callable和FutureTask创建线程

@Test
public void callableTest() throws ExecutionException, InterruptedException {
   Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
   FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
   Thread thread = new Thread(ft);
   thread.start();

   int result = ft.get();//当前是阻塞
}

public class MyCallable implements Callable<Integer>{

   @Override
   public Integer call() throws Exception {
       System.out.println("MyCallable create");
       return 0;
   }
}

在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。

D.通过线程池创建线程

Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口

I.newSingleThreadExecutor

创建一个单线程化的Executor

@Test
public void executeSingleTest() {
   Runnable runnable = new MyRunnable();
   ExecutorService  executorService = Executors.newSingleThreadExecutor();
   executorService.submit(runnable);
}

II.newCachedThreadPool

创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

@Test
public void executeCacheTest() {
   Runnable runnable = new MyRunnable();
   ExecutorService  executorService = Executors.newCachedThreadPool();
   executorService.submit(runnable);
}

III.newScheduledThreadPool

创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。

@Test
public void executeScheduledTest() {
   Runnable runnable = new MyRunnable();
   ExecutorService  executorService = Executors.newScheduledThreadPool(10);
   executorService.submit(runnable);
}

IIII.newFixedThreadPool

创建固定数目线程的线程池。

@Test
public void executeFixedTest() {
   Runnable runnable = new MyRunnable();
   ExecutorService  executorService = Executors.newFixedThreadPool(10);
   executorService.submit(runnable);
}

2、CompletableFuture 异步并发

JAVA8 CompletableFuture能够将回调放到与任务不同的线程中执行，也能将回调作为继续执行的同步函数，在与任务相同的线程中执行。它避免了传统回调最大的问题，那就是能够将控制流分离到不同的事件处理器中。

@Test
public void completableFutureTest() throws ExecutionException, InterruptedException {
   ExecutorService  executorService = Executors.newFixedThreadPool(100);
   CompletableFuture<String> future1 = CompletableFuture.supplyAsync(()->{
       System.out.println("查询图片");
       return "image_path";
   });

   CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()->{
       System.out.println("查询商品");
       return "product";
   });

   CompletableFuture<String> future3 = CompletableFuture.supplyAsync(()->{
       System.out.println("查询SKU");
       return "SKU";
   });

   //等待所有的运行完成，返回
   CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);
   allOf.get();

   //任何一个执行完成，返回
   CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2, future3);
   anyOf.get();
}

详细使用参考文档：https://www.jianshu.com/p/dff9063e1ab6

thread 并发编程

更多相关内容

Java多线程异步处理

千次阅读 2020-04-21 14:34:00

1.异步执行无返回值 CompletableFuture noArgsFuture = CompletableFuture.runAsync(new Runnable() { @Override public void run() { System.out.println("***************"); ...

1.异步执行无返回值

 CompletableFuture noArgsFuture = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                System.out.println("***************");
            }
        });

2.异步执行有返回值

 CompletableFuture<String> returnString = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "abc";
            }
        });
        String result = returnString.get();
        System.out.println(result);

3.多个异步执行，等待所有结果返回才算完成

 CompletableFuture<String> feature1 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "abc";
            }
        });
        CompletableFuture<String> feature2 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "def";
            }
        });
        CompletableFuture<String> feature3 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "ghi";
            }
        });
        CompletableFuture totalFeature = CompletableFuture.allOf(feature1, feature2, feature3);
        totalFeature.join();
        String str3=feature3.get();
        String str2=feature2.get();
        String str1=feature1.get();
        List<String> stringList = Stream.of(feature1, feature2, feature3).map(CompletableFuture::join).collect(Collectors.toList());
        System.out.println(stringList);
        System.out.println(str1+str2+str3);

4.多个异步执行，有参数有返回值

        //模拟入参
        List<Date> dates = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            dates.add(sdf.parse("2020-02-22 12:12:01"));
            dates.add(sdf.parse("2020-02-23 12:12:01"));
            dates.add(sdf.parse("2020-02-24 12:12:01"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        List<CompletableFuture<String>> futures = new ArrayList<>();
        //将任务提交，并异步执行
        for (Date date : dates) {
            CompletableFuture<String> newFeature = CompletableFuture.supplyAsync(new Supplier<String>() {
                @Override
                public String get() {
                    //异步处理逻辑，这里将日期转换为字符串
                    return coverLongToString(date);
                }
            });
            futures.add(newFeature);
        }
        //所有任务执行完成返回才会继续，不然会阻塞在这里等待
        //TODO 这里怎么能够设置下超时时间
        CompletableFuture.allOf(futures.iterator().next());
        //拿到所有异步线程返回的结果
        List<String> dateStringList = futures.stream().map(CompletableFuture::join).collect(Collectors.toList());
        System.out.println(dateStringList);

收起

展开全文

Java多线程实现异步调用的方法
2020-09-03 07:27:34

本文给大家分享java多线程实现异步调用的方法，感兴趣的朋友跟着脚本之家小编一起学习吧

收起

JAVA多线程编程之异步

2022-05-29 09:52:40

为了缩短响应时间，通常会使用异步处理多任务。需求举例：查询书籍基本信息，书籍详细信息，作者信息并将结果数据返回。假设查询书籍基本信息花费500毫秒，查询书籍详细信息花费500毫秒，查询作者信息花费500毫秒...

日常开发中我们在一个接口中需要处理多个任务，通常都是串行的，这样导致接口的响应时间是每个任务的执行时间的总和。为了缩短响应时间，通常会使用异步处理多任务。

需求举例：查询书籍基本信息，书籍详细信息，作者信息并将结果数据返回。
假设查询书籍基本信息花费500毫秒，查询书籍详细信息花费500毫秒，查询作者信息花费500毫秒，共计1500毫秒，使用异步处理时间一般都是远小于1500毫秒的。

下面使用异步调用方式优化接口

1、异步任务类

实现 Callable 接口，用来处理带返回结果的任务。taskId 用来区别返回结果集数据

package com.example.demo.task;

import java.util.concurrent.Callable;

/**
 * 异步任务
 * @param <T>
 */
public class AsynTaskCallable<T> implements Callable<T>{

    private String taskId;

    private Callable<T> task;

    public AsynTaskCallable(String taskId, Callable<T> task) {
        this.taskId = taskId;
        this.task = task;
    }

    @Override
    public T call() throws Exception {
        T callResult = task.call();
        TaskResult result = new TaskResult();
        result.setTaskId(taskId);
        result.setData(callResult);
        return (T) result;
    }

}

2、异步任务调用类

用来调用异步任务辅助类，completionService 用来指定线程池执行异步任务，tasks 为带返回结果的任务，可以实现多场景复用，减少重复编写相似的代码。

package com.example.demo.task;

import com.sun.istack.internal.NotNull;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

/**
 * 异步任务调用
 */
public class AsynTaskHelper<T> {

    /**
     * 使用指定线程池执行异步任务
     */
    private CompletionService<TaskResult<T>> completionService = null;

    /**
     * 任务集合
     */
    private List<Callable> tasks = null;

    /**
     * 设置线程池
     * @param executorService 线程池
     * @return
     */
    public AsynTaskHelper setExecutorService(ExecutorService executorService){
        completionService = new ExecutorCompletionService(executorService);
        return this;
    }

    /**
     * 添加任务，返回结果
     * @param taskId
     * @param task
     * @return
     */
    public AsynTaskHelper addTask(String taskId, Callable<T> task) {
        AsynTaskCallable callProxy = new AsynTaskCallable(taskId, task);
        if(null == tasks || tasks.isEmpty()){
            tasks = new ArrayList<>();
        }
        tasks.add(callProxy);
        return this;
    }

    /**
     * 提交任务
     * @return
     */
    public AsynTaskHelper submit(){
        if(null != tasks && !tasks.isEmpty()){
            for (Callable callResult : tasks) {
                completionService.submit(callResult);
            }
        }
        return this;
    }

    /**
     * 获取返回结果
     * @return Map<K, V> K为任务Id
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public Map<String, T> getResult() throws ExecutionException, InterruptedException {
        return getResult(2, TimeUnit.SECONDS);
    }

    /**
     * 获取返回结果
     * @param timeout
     * @param unit
     * @return Map<K, V> K为任务Id
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public Map<String, T> getResult(long timeout,@NotNull TimeUnit unit) throws InterruptedException, ExecutionException {
        Map<String, T> result = new HashMap<>();
        if(null == tasks){
            return result;
        }
        for (int i = 0; i < tasks.size(); i++) {
            Future<TaskResult<T>> poll = completionService.poll(timeout, unit);
            if(null != poll){
                TaskResult<T> task = poll.get();
                if(null != poll && null != task){
                    result.put(task.getTaskId(), task.getData());
                }
            }
        }
        return result;
    }

}

3、任务结果类

用来接收异步任务返回结果数据

package com.example.demo.task;

/**
 * 任务结果数据
 * @param <T>
 */
public class TaskResult<T> {

    /**
     * 任务Id
     */
    private String taskId;

    /**
     * 返回数据
     */
    private T data;

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "TaskResult{" +
                "taskId='" + taskId + '\'' +
                ", data=" + data +
                '}';
    }
}

4、异步调用

指定线程池执行任务

ExecutorService executor = Executors.newFixedThreadPool(500);

正常业务操作

//查询Book信息
Callable<Book> bookCall = () -> bookService.get(bookId);
//查询BookDetail信息
Callable<BookDetail> bookDetailCall = () -> bookDetailService.get(bookId);
//查询Author信息
Callable<Author> auhtorCall = () -> authorService.get(bookId);

创建异步任务

//创建异步任务
AsynTaskHelper taskCallors = new AsynTaskHelper()
         .setExecutorService(executor)
         .addTask("book", bookCall)
         .addTask("bookDetail", bookDetailCall)
         .addTask("author", auhtorCall)
         .submit();

获取结果，因为任务是异步的，可能第一时间拿不到结果，这里使用自旋的方式获取结果，如果3秒后还是没有结果则直接返回。

do{
   Map map = taskCallors.getResult();
    book = (Book) map.get("book");
    bookDetail = (BookDetail) map.get("bookDetail");
    author = (Author) map.get("author");
    runTime = System.currentTimeMillis() - beginTime;
} while ((null == book || null == bookDetail || null == author) && runTime < 3000);

完整示例调用代码

package com.example.demo.controller;

import com.example.demo.domain.Author;
import com.example.demo.domain.Book;
import com.example.demo.domain.BookDetail;
import com.example.demo.service.AuthorService;
import com.example.demo.service.BookDetailService;
import com.example.demo.service.BookService;
import com.example.demo.task.AsynTaskHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

@RestController
public class BookController {

    @Autowired
    private BookService bookService;

    @Autowired
    private BookDetailService bookDetailService;

    @Autowired
    private AuthorService authorService;

    private ExecutorService executor = Executors.newFixedThreadPool(500);

    @GetMapping("books5/{bookId}")
    public Map find5(@PathVariable String bookId) throws ExecutionException, InterruptedException {
        Map<String, Object> result = new HashMap<>();

        Long beginTime = System.currentTimeMillis();
        System.out.println("开始并行查询，开始时间：" + beginTime);
        //查询Book信息
        Callable<Book> bookCall = () -> bookService.get(bookId);
        //查询BookDetail信息
        Callable<BookDetail> bookDetailCall = () -> bookDetailService.get(bookId);
        //查询Author信息
        Callable<Author> auhtorCall = () -> authorService.get(bookId);

        //创建异步任务
        AsynTaskHelper taskCallors = new AsynTaskHelper()
                .setExecutorService(executor)
                .addTask("book", bookCall)
                .addTask("bookDetail", bookDetailCall)
                .addTask("author", auhtorCall)
                .submit();

        Book book = null;
        BookDetail bookDetail = null;
        Author author = null;
        
        long runTime;
        do{
            Map map = taskCallors.getResult();
            book = (Book) map.get("book");
            bookDetail = (BookDetail) map.get("bookDetail");
            author = (Author) map.get("author");
            runTime = System.currentTimeMillis() - beginTime;
        } while ((null == book || null == bookDetail || null == author) && runTime < 3000);

        System.out.println("结束并行查询,总耗时：" + (System.currentTimeMillis() - beginTime));
        result.put("book", book);
        result.put("detail", bookDetail);
        result.put("author", author);

        return result;
    }

}

通过 AsynTaskHelper 调用异步任务能缩短接口响应时间，进而提升系统并发能力，后续有类似的使用场景也支持复用，减少重复编码工作。

收起

展开全文

Future 并发编程高并发

Java创建多线程异步执行实现代码解析
2020-08-18 17:48:08

主要介绍了Java创建多线程异步执行实现代码解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

收起
Java多线程之定时任务以及 SpringBoot多线程实现定时任务——异步任务
2022-03-12 17:59:54

1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled

收起
浅谈java中异步多线程超时导致的服务异常
2020-09-02 02:42:38

下面小编就为大家带来一篇浅谈java中异步多线程超时导致的服务异常。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧

收起
Java多线程实现异步调用实例
2014-09-18 15:09:21

Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程，另有A,B,C三个线程用不同的时间跑完。

收起

【Java多线程】多线程实现异步调用结果返回

千次阅读 2020-05-18 20:01:15

因此可以使用异步调用的方法，不阻塞当前其他任务的执行。小栗子首先我们先要创建一个线程池，可以根据自己的需求创建，什么IO密集型参数设置，CPU密集型参数的设置。这里我们仅仅想让10个任务一起跑。 ...

前言

在我们的业务中很可能会碰到需要执行一段时间的任务，并且如果同步的话就会造成一些无谓的等待。因此可以使用异步调用的方法，不阻塞当前其他任务的执行。

小栗子

首先我们先要创建一个线程池，可以根据自己的需求创建，什么IO密集型参数设置，CPU密集型参数的设置。这里我们仅仅想让10个任务一起跑。

ExecutorService threadPool = new ThreadPoolExecutor(
                        10,
                        10,
                        0,
                        TimeUnit.SECONDS,
                        new SynchronousQueue<>(),
                        new ThreadPoolExecutor.AbortPolicy());

然后模拟下需要异步调用的业务的执行,这里我的n给不同线程设置了不同的执行时间，在判断超时时，会有部分线程无法完成任务。

AtomicInteger atomicInteger = new AtomicInteger(5);
List<Future<Integer>> futures = new ArrayList<>(); //存储结果
for (int i = 0; i < 10; i++) {
            Future<Integer> submit = completionService.submit(() -> {
                int n = atomicInteger.getAndIncrement();
                int h = 0;
                for (int j = n * 10; j < n * 10 + n; j++) {
                    h += j;
                    TimeUnit.SECONDS.sleep(1); //暂停线程1s
                }
                return h;

            });
            futures.add(submit);
        }

现在执行下其他的业务操作。

然后设置一些调用其他接口超时的时间，避免过长等待并开始获取下调用的结果。

		Set<AjaxResult> flags = new HashSet<>();
        List<AjaxResult> FAILS =new LinkedList<>();
        long startTime = System.currentTimeMillis();
        long timeout = 1000 * 10;
         while (flags.size()+FAILS.size()<futures.size()) {
            for (Future<Integer> o : futures) {
                if (System.currentTimeMillis() - startTime > timeout ){// 如果超时采取一定措施，或者返回一个失败。
                    FAILS.add(new AjaxResult("fail",0));
                    if(flags.size()+FAILS.size()>=futures.size()){
                        break;
                    }
                    continue;
                }
                if (o.isDone()) {
                    flags.add(new AjaxResult("success", o.get()));
                }
            }

         }
        long endTime = System.currentTimeMillis();

这里将结果分失败和成功进行存储。并记录处理的时间

接下来看下最后输出结果

		System.out.println("执行结束");
        System.out.println("耗时" + (endTime - startTime));
        System.out.println("结果" + flags.toString());
        System.out.println("失败" + FAILS.toString());
        System.exit(0);

在这里插入图片描述
本方法纯属瞎玩，仅供参考。

下面是全部的代码

public class InitConfig {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService threadPool = new ThreadPoolExecutor(
                        10,
                        10,
                        0,
                        TimeUnit.SECONDS,
                        new SynchronousQueue<>(),
                        new ThreadPoolExecutor.AbortPolicy());
        CompletionService<Integer> completionService = new ExecutorCompletionService<>(threadPool);
        AtomicInteger atomicInteger = new AtomicInteger(5);
        List<Future<Integer>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<Integer> submit = completionService.submit(() -> {
                int n = atomicInteger.getAndIncrement();
                int h = 0;
                for (int j = n * 10; j < n * 10 + n; j++) {
                    h += j;
                    TimeUnit.SECONDS.sleep(1); //暂停线程1s
                }
                return h;

            });
            futures.add(submit);
        }
        Set<AjaxResult> flags = new HashSet<>();
        List<AjaxResult> FAILS =new LinkedList<>();
        long startTime = System.currentTimeMillis();
        long timeout = 1000 * 10;
         while (flags.size()+FAILS.size()<futures.size()) {
            for (Future<Integer> o : futures) {
                if (System.currentTimeMillis() - startTime > timeout ){
                    FAILS.add(new AjaxResult("fail",0));
                    if(flags.size()+FAILS.size()>=futures.size()){
                        break;
                    }
                    continue;
                }
                if (o.isDone()) {
                    flags.add(new AjaxResult("success", o.get()));
                }
            }

         }
        long endTime = System.currentTimeMillis();
        System.out.println("执行结束");
        System.out.println("耗时" + (endTime - startTime));
        System.out.println("结果" + flags.toString());
        System.out.println("失败" + FAILS.toString());
        System.exit(0);
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    @EqualsAndHashCode
    static class AjaxResult {
        private String ret;
        private Integer data;
    }


}

收起

展开全文

并发编程

java多线程异步实例
2012-11-19 11:17:28

java线程异步案例，以三个线程作为案例典型，同时发起三个线程，根据不同的订单领取各自的物品，自作过程同步处理。

收起
java多线程读取多个文件的方法
2020-08-25 17:01:35

主要为大家详细介绍了java多线程读取多个文件的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

收起
java使用线程异步返回结果
2021-04-26 21:05:06

public class JavaPromise { public static void main(String[] args) throws Exception { ExecutorService executorService = Executors.newSingleThreadExecutor(); // submit有返回值 execute方法没有 ...

收起
java多线程异步执行
2021-02-26 21:42:08

importjava.util.concurrent.Callable;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.Future;publ...

收起
用JAVA写的一个异步多线程批处理的组件
热门讨论 2011-06-29 17:16:22

为了方便以后的开发，写了个异步多线程批处理的组件具体用法见代码里的说明。很多时候都需要处理大批量数据，以后就方便多了

收起
Java程序框架--多线程异步处理多任务
热门讨论 2010-08-15 16:28:59

本程序提供了一个多任务多线程异步处理框架。该框架使用简单，用户只需要继承抽象类Task,构建自己的任务类，再构造一个任务源，就可以轻松使用这个框架。程序包里提供了一个例子Mytask 和MyTaskGenerator, 用户只...

收起
java多线程实现java后台异步调用
2021-09-08 16:46:22

例如：批量导入信息、信息过多，前台等待时间过久会发生连接超时情况可以用java多线程实现异步请求。（此例子适用于子方法不会发生异常的情况下）。 ``` public class Test { static boolean flage = true; ...

收起

javascript
java多线程之异步使用
千次阅读 2021-02-25 20:01:50

在编程中,根据实际场景,我们有时会考虑使用异步执行来提高应用的响应速度;一个简单的例子:@Testpublic void futureTest() {// 注意使用 ExecutorService 而非 ExecutorExecutorService executorService = Executors....

收起
Java 多线程同步和异步详解
2022-03-06 12:59:24

系统处理性能，加在多线程并发时资源挣夺最激烈的地方，这就实现了线程的同步机制同步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为同步机制存在，A线程请求不到，怎么办，A线程只能等待下去异步：A...

收起

开发语言后端
多线程异步处理时的事务管理(含返回值)
2021-03-05 14:12:53

下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。 import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.transaction.PlatformTransactionManager; import org...

收起

spring
Java 异步多线程有哪些实现方式？
2021-04-28 15:10:47

异步多线程的四种方式：继承Thread 实现Runnable接口实现Callable+FutureTask 线程池一、继承Thread public class ThreadTest{ public static void main(String[] args) { Thread thread = new Thread01()...

收起
多线程异步任务处理
千次阅读 2018-11-07 21:29:31

文章目录多线程异步任务处理线程池线程池的优缺点常用的线程池技术@Async注解源码我们常用ThreadPoolExecutor提供的线程池服务，springboot框架提供了@Async注解，那我们怎么去使用它呢？我们先来了解下什么是...

收起

并发
java如何实现异步处理
千次阅读 2021-02-12 12:03:06

例如多线程中某个线程需要等待其他线程结束才继续执行、某个线程需要从其他线程获取数据等，都需要用到线程之间的通信。同步也可以看成是线程协作通信的其中一种。本节主要介绍常用线程通信技术：线程之间的参数传递...

收起
Java使用多线程异步执行批量更新操作
千次阅读 热门讨论 2021-01-11 00:16:32

因此，开多线程来执行批量任务是十分重要的一种批量操作思路，其实这种思路实现起来也十分简单，就拿批量更新的操作举例：整体流程图步骤获取需要进行批量更新的大集合A，对大集合进行拆分操作，分成N个小集合A...

收起
Java多线程获取异步执行结果的多种姿势
千次阅读 2021-03-12 23:29:27

直接另开一个线程执行即可，但是如果遇到一些需要获取执行结果的业务，就只能为了多线程异步方式再引入线程间通信逻辑，便显得捉襟见肘。 jdk 1.5以后新引入了Future和Calla

收起
JAVA CompletableFuture（异步多线程）真香
千次阅读 2021-04-13 11:14:09

可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。可见，这种方式才是我们需要的异步处理。一个控制流的多个异步事件处理能无缝的连接在一起。举个...

收起

future
Java多线程分批处理数据
千次阅读 2019-03-17 11:59:22

场景：发短信，当有数据量庞大的短信需要发送时，可以采用多线程的方式分批处理以提高效率，但线程要控制合适的数量，否则会极大消耗CPU资源上代码：创建分页类PageUtil /** * 分页 * @param list 切割数据...

收起
通过多线程任务处理大批量耗时业务并返回结果
2020-11-16 11:11:49

通过多线程处理大批量耗时业务，并返回结果。当监测到线程池中存在空闲线程时则动态向线程池中添加新的任务，直到所有任务执行结束。Demo为自己写的测试使用，下载后可直接运行测试。

收起
Java多线程编程-（17）-多线程异步调用之Future模式
万次阅读 2017-10-30 10:27:27

一、线程计数器回顾在《Java多线程编程-（6）-两种常用的线程计数器CountDownLatch和循环屏障CyclicBarrier》这一篇中，我们使用线程计数器的方式实现了在主线程中等待计数的线程执行完之后在执行阻塞等待之后的...

收起

Future Callable futuretask
python多线程异步（一）
千次阅读 2021-11-28 20:18:30

现在工作中又遇到必须要通过多线程解决的问题，所以再回顾以前方老师的课程，从头整理一下多线程异步这块知识，方便以后遇到问题可以快速写出代码来。目录1、多线程异步初步介绍1.1一般的异步demo1.2傀儡线程2、...

收起

python

1、Java多线程实现

A.继承Thread类，重写run方法

B.实现Runnable接口，重写run方法。

C.通过Callable和FutureTask创建线程

D.通过线程池创建线程

I.newSingleThreadExecutor

II.newCachedThreadPool

III.newScheduledThreadPool

IIII.newFixedThreadPool

2、CompletableFuture 异步并发

Java多线程异步处理

1.异步执行无返回值

2.异步执行有返回值

3.多个异步执行，等待所有结果返回才算完成

4.多个异步执行，有参数有返回值

Java多线程实现异步调用的方法

JAVA多线程编程之异步

1、异步任务类

2、异步任务调用类

3、任务结果类

4、异步调用

Java创建多线程异步执行实现代码解析

Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务

浅谈java中异步多线程超时导致的服务异常

Java多线程实现异步调用实例

【Java多线程】多线程实现异步调用结果返回

前言

小栗子

下面是全部的代码

java多线程异步实例

java多线程读取多个文件的方法

java使用线程异步返回结果

java多线程异步执行

用JAVA写的一个异步多线程批处理的组件

Java程序框架--多线程异步处理多任务

java多线程实现java后台异步调用

java多线程之异步使用

Java 多线程同步和异步详解

多线程异步处理时的事务管理(含返回值)

Java 异步多线程有哪些实现方式？

多线程异步任务处理

java如何实现异步处理

Java使用多线程异步执行批量更新操作

Java多线程获取异步执行结果的多种姿势

JAVA CompletableFuture（异步多线程）真香

Java多线程分批处理数据

通过多线程任务处理大批量耗时业务并返回结果

Java多线程编程-（17）-多线程异步调用之Future模式

python多线程异步（一）

java多线程异步处理

Java多线程之定时任务以及 SpringBoot多线程实现定时任务——异步任务