Callable接口和Runnable接口

来源：互联网发布：易辛模型Python 编辑：程序博客网时间：2024/06/15 19:48

1、

public interface Executor {    /**     * Executes the given command at some time in the future.  The command     * may execute in a new thread, in a pooled thread, or in the calling     * thread, at the discretion of the <tt>Executor</tt> implementation.     *     * @param command the runnable task     * @throws RejectedExecutionException if this task cannot be     * accepted for execution.     * @throws NullPointerException if command is null     */    void execute(Runnable command);}

//接口ExecutorService继承自Executor，它的目的是为我们管理Thread对象，从而简化并发编程public interface ExecutorService extends Executor {    <T> Future<T> submit(Callable<T> task);       <T> Future<T> submit(Runnable task, T result);    Future<?> submit(Runnable task);    ...   }

public interface Callable<V> {    /**     * Computes a result, or throws an exception if unable to do so.     *     * @return computed result     * @throws Exception if unable to compute a result     */    V call() throws Exception;}public interface Runnable {       public abstract void run();}

public interface Future<V> {        boolean cancel(boolean mayInterruptIfRunning);        /**     * Waits if necessary for the computation to complete, and then     * retrieves its result.     *     * @return the computed result       */    V get() throws InterruptedException, ExecutionException;       V get(long timeout, TimeUnit unit)        throws InterruptedException, ExecutionException, TimeoutException;}

Callable接口和Runnable接口相似，区别就是Callable需要实现call方法，而Runnable需要实现run方法；并且，call方法还可以返回任何对象，无论是什么对象，JVM都会当作Object来处理。但是如果使用了泛型，我们就不用每次都对Object进行转换了。

Runnable和Callable都是接口

不同之处：
1.Callable可以返回一个类型V，而Runnable不可以
2.Callable能够抛出checked exception,而Runnable不可以。
3.Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的
4.Callable和Runnable都可以应用于executors。而Thread类只支持Runnable.
上面只是简单的不同，其实这两个接口在用起来差别还是很大的。Callable与executors联合在一起，在任务完成时可立刻获得一个更新了的Future。而Runable却要自己处理

Future接口，一般都是取回Callable执行的状态用的。其中的主要方法：

cancel，取消Callable的执行，当Callable还没有完成时
get，获得Callable的返回值
isCanceled，判断是否取消了
isDone，判断是否完成

用Executor来构建线程池，应该要做的事：

1).调用Executors类中的静态方法newCachedThreadPool(必要时创建新线程，空闲线程会被保留60秒)或newFixedThreadPool(包含固定数量的线程池)等，返回的是一个实现了ExecutorService接口的ThreadPoolExecutor类或者是一个实现了ScheduledExecutorServiece接口的类对象。

2).调用submit提交Runnable或Callable对象。

3).如果想要取消一个任务，或如果提交Callable对象，那就要保存好返回的Future对象。

4).当不再提交任何任务时，调用shutdown方法。

举2个例子如下：

Java代码    
package thread.test04;  
import java.util.concurrent.*;  
public class ThreadTestA {  
    public static void main(String[] args) {  
        ExecutorService e=Executors.newFixedThreadPool(10);  
        e.execute(new MyRunnableA());  
        e.execute(new MyRunnableB());  
       e.shutdown();  
   }  
  
}  
  
class MyRunnableA implements Runnable{  
      
    public void run(){  
        System.out.println("Runnable:run()....");  
        int i=0;  
        while(i<20){  
            i++;  
            for(int j=0;j<1000000;j++);  
            System.out.println("i="+i);  
        }  
    }  
}  
  
class MyRunnableB implements Runnable{  
    public void run(){  
        char c='A'-1;  
        while(c<'Z'){  
            c++;  
            for(int j=0;j<1000000;j++);  
            System.out.println("c="+c);  
        }  
    }  
}  

Java代码    
package thread.test04;  
  
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 ThreadTestB {  
    public static void main(String[] args) {  
        ExecutorService e=Executors.newFixedThreadPool(10);  
        Future f1=e.submit(new MyCallableA());  
        Future f2=e.submit(new MyCallableA());  
        Future f3=e.submit(new MyCallableA());        
        System.out.println("--Future.get()....");  
        try {  
            System.out.println(f1.get());  
            System.out.println(f2.get());  
            System.out.println(f3.get());            
        } catch (InterruptedException e1) {  
            e1.printStackTrace();  
        } catch (ExecutionException e1) {  
            e1.printStackTrace();  
        }  
          
        e.shutdown();  
          
    }  
  
}  
  
class MyCallableA implements Callable<String>{  
    public String call() throws Exception {  
        System.out.println("开始执行Callable");  
        String[] ss={"zhangsan","lisi"};  
        long[] num=new long[2];  
        for(int i=0;i<1000000;i++){  
            num[(int)(Math.random()*2)]++;  
        }  
          
        if(num[0]>num[1]){  
            return ss[0];  
        }else if(num[0]<num[1]){  
            throw new Exception("弃权!");  
        }else{  
            return ss[1];  
        }  
    }  
      
}  

来源：http://junlas.iteye.com/blog/846457

/** * Factory and utility methods for {@link Executor}, {@link * ExecutorService}, {@link ScheduledExecutorService}, {@link * ThreadFactory}, and {@link Callable} classes defined in this * package. This class supports the following kinds of methods: * * <ul> *   <li> Methods that create and return an {@link ExecutorService} *        set up with commonly useful configuration settings. *   <li> Methods that create and return a {@link ScheduledExecutorService} *        set up with commonly useful configuration settings. *   <li> Methods that create and return a "wrapped" ExecutorService, that *        disables reconfiguration by making implementation-specific methods *        inaccessible. *   <li> Methods that create and return a {@link ThreadFactory} *        that sets newly created threads to a known state. *   <li> Methods that create and return a {@link Callable} *        out of other closure-like forms, so they can be used *        in execution methods requiring <tt>Callable</tt>. * </ul> * * @since 1.5 * @author Doug Lea */public class Executors {    /**     * Creates a thread pool that reuses a fixed number of threads     * operating off a shared unbounded queue.  At any point, at most     * <tt>nThreads</tt> threads will be active processing tasks.     * If additional tasks are submitted when all threads are active,     * they will wait in the queue until a thread is available.     * If any thread terminates due to a failure during execution     * prior to shutdown, a new one will take its place if needed to     * execute subsequent tasks.  The threads in the pool will exist     * until it is explicitly {@link ExecutorService#shutdown shutdown}.     *     * @param nThreads the number of threads in the pool     * @return the newly created thread pool     * @throws IllegalArgumentException if <tt>nThreads &lt;= 0</tt>     */    public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue<Runnable>());    }    /**     * Creates a thread pool that reuses a fixed number of threads     * operating off a shared unbounded queue, using the provided     * ThreadFactory to create new threads when needed.  At any point,     * at most <tt>nThreads</tt> threads will be active processing     * tasks.  If additional tasks are submitted when all threads are     * active, they will wait in the queue until a thread is     * available.  If any thread terminates due to a failure during     * execution prior to shutdown, a new one will take its place if     * needed to execute subsequent tasks.  The threads in the pool will     * exist until it is explicitly {@link ExecutorService#shutdown     * shutdown}.     *     * @param nThreads the number of threads in the pool     * @param threadFactory the factory to use when creating new threads     * @return the newly created thread pool     * @throws NullPointerException if threadFactory is null     * @throws IllegalArgumentException if <tt>nThreads &lt;= 0</tt>     */    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue<Runnable>(),                                      threadFactory);    }    /**     * Creates an Executor that uses a single worker thread operating     * off an unbounded queue. (Note however that if this single     * thread terminates due to a failure during execution prior to     * shutdown, a new one will take its place if needed to execute     * subsequent tasks.)  Tasks are guaranteed to execute     * sequentially, and no more than one task will be active at any     * given time. Unlike the otherwise equivalent     * <tt>newFixedThreadPool(1)</tt> the returned executor is     * guaranteed not to be reconfigurable to use additional threads.     *     * @return the newly created single-threaded Executor     */    public static ExecutorService newSingleThreadExecutor() {        return new FinalizableDelegatedExecutorService            (new ThreadPoolExecutor(1, 1,                                    0L, TimeUnit.MILLISECONDS,                                    new LinkedBlockingQueue<Runnable>()));    }    /**     * Creates an Executor that uses a single worker thread operating     * off an unbounded queue, and uses the provided ThreadFactory to     * create a new thread when needed. Unlike the otherwise     * equivalent <tt>newFixedThreadPool(1, threadFactory)</tt> the     * returned executor is guaranteed not to be reconfigurable to use     * additional threads.     *     * @param threadFactory the factory to use when creating new     * threads     *     * @return the newly created single-threaded Executor     * @throws NullPointerException if threadFactory is null     */    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {        return new FinalizableDelegatedExecutorService            (new ThreadPoolExecutor(1, 1,                                    0L, TimeUnit.MILLISECONDS,                                    new LinkedBlockingQueue<Runnable>(),                                    threadFactory));    }    /**     * Creates a thread pool that creates new threads as needed, but     * will reuse previously constructed threads when they are     * available.  These pools will typically improve the performance     * of programs that execute many short-lived asynchronous tasks.     * Calls to <tt>execute</tt> will reuse previously constructed     * threads if available. If no existing thread is available, a new     * thread will be created and added to the pool. Threads that have     * not been used for sixty seconds are terminated and removed from     * the cache. Thus, a pool that remains idle for long enough will     * not consume any resources. Note that pools with similar     * properties but different details (for example, timeout parameters)     * may be created using {@link ThreadPoolExecutor} constructors.     *     * @return the newly created thread pool     */    public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                      60L, TimeUnit.SECONDS,                                      new SynchronousQueue<Runnable>());    }    /**     * Creates a thread pool that creates new threads as needed, but     * will reuse previously constructed threads when they are     * available, and uses the provided     * ThreadFactory to create new threads when needed.     * @param threadFactory the factory to use when creating new threads     * @return the newly created thread pool     * @throws NullPointerException if threadFactory is null     */    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                      60L, TimeUnit.SECONDS,                                      new SynchronousQueue<Runnable>(),                                      threadFactory);    }    /**     * Creates a single-threaded executor that can schedule commands     * to run after a given delay, or to execute periodically.     * (Note however that if this single     * thread terminates due to a failure during execution prior to     * shutdown, a new one will take its place if needed to execute     * subsequent tasks.)  Tasks are guaranteed to execute     * sequentially, and no more than one task will be active at any     * given time. Unlike the otherwise equivalent     * <tt>newScheduledThreadPool(1)</tt> the returned executor is     * guaranteed not to be reconfigurable to use additional threads.     * @return the newly created scheduled executor     */    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {        return new DelegatedScheduledExecutorService            (new ScheduledThreadPoolExecutor(1));    }    /**     * Creates a single-threaded executor that can schedule commands     * to run after a given delay, or to execute periodically.  (Note     * however that if this single thread terminates due to a failure     * during execution prior to shutdown, a new one will take its     * place if needed to execute subsequent tasks.)  Tasks are     * guaranteed to execute sequentially, and no more than one task     * will be active at any given time. Unlike the otherwise     * equivalent <tt>newScheduledThreadPool(1, threadFactory)</tt>     * the returned executor is guaranteed not to be reconfigurable to     * use additional threads.     * @param threadFactory the factory to use when creating new     * threads     * @return a newly created scheduled executor     * @throws NullPointerException if threadFactory is null     */    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {        return new DelegatedScheduledExecutorService            (new ScheduledThreadPoolExecutor(1, threadFactory));    }    /**     * Creates a thread pool that can schedule commands to run after a     * given delay, or to execute periodically.     * @param corePoolSize the number of threads to keep in the pool,     * even if they are idle.     * @return a newly created scheduled thread pool     * @throws IllegalArgumentException if <tt>corePoolSize &lt; 0</tt>     */    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {        return new ScheduledThreadPoolExecutor(corePoolSize);    }    /**     * Creates a thread pool that can schedule commands to run after a     * given delay, or to execute periodically.     * @param corePoolSize the number of threads to keep in the pool,     * even if they are idle.     * @param threadFactory the factory to use when the executor     * creates a new thread.     * @return a newly created scheduled thread pool     * @throws IllegalArgumentException if <tt>corePoolSize &lt; 0</tt>     * @throws NullPointerException if threadFactory is null     */    public static ScheduledExecutorService newScheduledThreadPool(            int corePoolSize, ThreadFactory threadFactory) {        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);    }    ........    /** Cannot instantiate. */    private Executors() {}}

0 0