Concurrent - execute() & submit()

原创转载请注明出处：http://agilestyle.iteye.com/blog/2343704

execute()

execute()没有返回值，在默认的情况下异常直接抛出，不能捕获，但可以通过自定义ThreadFactory的方式进行捕获

 

submit()

submit()有返回值，在默认的情况下，可以catch ExecutionException捕获异常

 

execute无返回值，submit有返回值

FutureCallableTest7.java

package org.fool.java.concurrent.futurecallable;

import java.util.concurrent.*;

public class FutureCallableTest7 {
    public static void main(String[] args) {
        try {
            ExecutorService executor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("execute() invoked..., no return value...");
                }
            });

            Future<String> future = executor.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("submit() invoked..., has return value...");
                    return "data";
                }
            });

            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Run

 

execute出现异常后直接打印堆栈信息

FutureCallableTest8.java

package org.fool.java.concurrent.futurecallable;

import java.util.concurrent.*;

public class FutureCallableTest8 {
    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        executor.execute(new Runnable() {
            @Override
            public void run() {
                Integer.parseInt("a");
            }
        });
    }
}

Run

 

submit()可以捕获异常

FutureCallableTest9.java

package org.fool.java.concurrent.futurecallable;

import java.util.concurrent.*;

public class FutureCallableTest9 {
    public static void main(String[] args) {
        try {
            ExecutorService executor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

            Future<String> future = executor.submit(new Callable<String>() {

                @Override
                public String call() throws Exception {
                    Integer.parseInt("a");
                    return "data exception";
                }
            });

            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            System.out.println("ExecutionException catched...");
            e.printStackTrace();
        }
    }
}

Run

 

execute()自定义ThreadFactory的方式进行捕获异常

FutureCallableTest10.java

package org.fool.java.concurrent.futurecallable;

import java.util.concurrent.*;

public class FutureCallableTest10 {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        executor.setThreadFactory(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);

                t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                    @Override
                    public void uncaughtException(Thread t, Throwable e) {
                        System.out.println("Custom Exception in execute()");
                        e.printStackTrace();
                    }
                });

                return t;
            }
        });

        executor.execute(new Runnable() {
            @Override
            public void run() {
                Integer.parseInt("a");
            }
        });
    }
}

Run