多线程之 ExecutorService的submit

Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。

 

一、创建任务

（1）、任务就是一个实现了Runnable接口的类。创建的时候实run方法即可。

（2）、任务是一个实现了Callable接口的类，实现call方法即可。

二、执行任务

1、创建ExecutorService

通过工具类java.util.concurrent.Executors的静态方法来创建。

Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

 

比如，创建一个ExecutorService的实例，ExecutorService实际上是一个线程池的管理工具：

        ExecutorService executorService = Executors.newCachedThreadPool();

        ExecutorService executorService = Executors.newFixedThreadPool(3);

        ExecutorService executorService = Executors.newSingleThreadExecutor();

 

2、将任务添加到线程去执行

当将一个任务添加到线程池中的时候，线程池会为每个任务创建一个线程，该线程会在之后的某个时刻自动执行。

当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。

同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。

三、关闭执行服务对象

        executorService.shutdown();这将导致其停止接受新任务。方法在终止前允许执行以前提交的任务，已经提交的当前任务会继续执行完成。

executorService.shutdownNow() 方法阻止等待任务启动并试图停止当前正在执行的任务。

 

四、返回值

当调用每次执行自然要等到get()方法获取到数据才能执行下一个线程

这是同步的代码：这种方式不好

for (int i = 0; i < count; i++) {
    total += pool.submit(
    tr.new Task(10000000 * rand.nextInt(100), i + "任务")).get();
    System.out.println("next task...");
}

 

只要把.get()方法拿到for循环外读取数据，就可以并发执行。

int count = 10;
        Future[] futures = new Future[count];
        for (int i = 0; i < count; i++) {
            futures[i] = pool.submit(tr.new Task(1 * rand.nextInt(100), i
                    + "任务"));
        }

案例一、实现runnable接口

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCachedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new TestRunnable());
            System.out.println("************* a" + i + " *************");
        }
        executorService.shutdown();
    }
}

class TestRunnable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");
            try {
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
}

返回值：

************* a0 *************
************* a1 *************
************* a2 *************
************* a3 *************
************* a4 *************
pool-1-thread-1线程被调用了。
pool-1-thread-2线程被调用了。
pool-1-thread-3线程被调用了。
pool-1-thread-4线程被调用了。
pool-1-thread-5线程被调用了。
pool-1-thread-4
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-5

 

案例二：实现Callable接口，停止线程调用的shutdownNow，会停止当前正在运行的线程，但是shutdown不会停止当前已经提交的线程。

import java.util.ArrayList;
        import java.util.List;
        import java.util.Random;
        import java.util.concurrent.Callable;
        import java.util.concurrent.ExecutionException;
        import java.util.concurrent.ExecutorService;
        import java.util.concurrent.Executors;
        import java.util.concurrent.Future;

public class CallTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<String>> resultList = new ArrayList<Future<String>>();

        // 创建10个任务并执行
        for (int i = 0; i < 10; i++) {
            // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future<String> future = executorService.submit(new TaskWithResult(i));
            // 将任务执行结果存储到List中
            resultList.add(future);
        }


        // 遍历任务的结果
        for (Future<String> fs : resultList) {
            try {
                // System.out.println(fs.get()); // 打印各个线程（任务）执行的结果
            } catch (Exception e) {
                executorService.shutdownNow();
                e.printStackTrace();
                return;
            }
        }
    }
}

class TaskWithResult implements Callable<String> {
    private int id;

    public TaskWithResult(int id) {
        this.id = id;
    }


    public String call() throws Exception {
        System.out.println("方法被自动调用,干活！！！             " + Thread.currentThread().getName());

        return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();
    }
}

执行结果：

方法被自动调用,干活！！！             pool-1-thread-1
方法被自动调用,干活！！！             pool-1-thread-2
方法被自动调用,干活！！！             pool-1-thread-1
方法被自动调用,干活！！！             pool-1-thread-3
方法被自动调用,干活！！！             pool-1-thread-4
方法被自动调用,干活！！！             pool-1-thread-5
方法被自动调用,干活！！！             pool-1-thread-6
方法被自动调用,干活！！！             pool-1-thread-7
方法被自动调用,干活！！！             pool-1-thread-8
方法被自动调用,干活！！！             pool-1-thread-9

所以说当有get 返回值调用的时候，才会执行return 那行语句。

所以说当代码中是这样是写的

            futures[i] = Executor.getExecutor().submit(new Callable<List<IfoxInstallAnaModel>>() {
                @Override
                public List<IfoxInstallAnaModel> call(){
                    return p2pClientDao.getIfoxInstallAndUNInstallData(map);
                }
            });

只有在get是才会去执行DAO方法。