for循环创建多线程同时调用接口

62 阅读 0 评论 41 点赞

我是靠谱客的博主怕孤独大炮，最近开发中收集的这篇文章主要介绍for循环创建多线程同时调用接口，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

多线程创建并同时调用接口

for 创建 runnable 方式

 public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        if (Thread.currentThread().getName().equals("Thread-31")) {
                            throw new Throwable();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (Throwable throwable) {
                        System.out.println("error  " + Thread.currentThread().getName());
                        throwable.printStackTrace();
                    }
                    System.out.println("aaaaa" + Thread.currentThread().getName());
                }
            }).start();
        }
    }

多线程运行过程中如果有一个线程抛出异常，将不会影响其他线程运行。
当你循环调用接口的时候就可以实现高性能调用，互不影响。
**

2.callable 方法 for 循环创建

 public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    Thread.sleep(1000);
                    if (Thread.currentThread().getName().equals("Thread-65")) {
                        try {
                            throw new Throwable();
                        } catch (Throwable throwable) {
                            System.err.println("currentThread:" + Thread.currentThread().getName());
                            throwable.printStackTrace();
                        }
                    }
                    System.err.println("aaaa" + Thread.currentThread().getName());
                    return null;
                }
            };
            FutureTask futureTask = new FutureTask(callable);
            try {
                new Thread(futureTask).start();
                //callable.call();  获取返回  多线程就不能同时执行。
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

需要注意的是如果要拿到返回结果。多个线程就不能同时运行，而是排队一个一个运行。改造方法如下3：

线程池方法运行线程并获取反回的结果；


public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义一个线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 20, 6000, TimeUnit.SECONDS, new ArrayBlockingQueue<>(60000));
        //创建自定义的一个对象
        MyCallable myCallable = new MyCallable();
        //创建集合用于存储任务
        List<Future> futures = new ArrayList<>();
        try {
            //循环提交任务到线程池中
            for (int i = 0; i < 10; i++) {
                Future<String> future = executor.submit(myCallable);
                futures.add(future);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("err");
        }

        //循环调用创建的任务
        for (Future<String> future : futures) {
            String s = future.get();
            //获取返回的结果
            System.out.println("result; " + s);
        }
        //关闭线程池的流
        executor.shutdown();
    }
}

/**
 * 自定义一个callable 的类
 */
class MyCallable implements Callable<String> {

    @Override
    public String call() {
        try {
            Thread.sleep(1000);

            if (Thread.currentThread().getName().equals("pool-1-thread-9")) {
                try {
                    throw new Throwable();
                } catch (Throwable throwable) {
                    System.err.println("error===== " + Thread.currentThread().getName());
                    throwable.printStackTrace();
                }
            }
            System.out.println("===wo de xian cheng" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            System.err.println("error===== " + Thread.currentThread().getName());
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("error===== " + Thread.currentThread().getName());
            e.printStackTrace();
        }
        //返回线程调用的结果
        return "ok" + Thread.currentThread().getName();
    }

}