`
uule
  • 浏览: 6297692 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

Callable接口和Runnable接口

 
阅读更多

 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代码   收藏代码
  1. package thread.test04;  
  2. import java.util.concurrent.*;  
  3. public class ThreadTestA {  
  4.     public static void main(String[] args) {  
  5.         ExecutorService e=Executors.newFixedThreadPool(10);  
  6.         e.execute(new MyRunnableA());  
  7.         e.execute(new MyRunnableB());  
  8.        e.shutdown();  
  9.    }  
  10.   
  11. }  
  12.   
  13. class MyRunnableA implements Runnable{  
  14.       
  15.     public void run(){  
  16.         System.out.println("Runnable:run()....");  
  17.         int i=0;  
  18.         while(i<20){  
  19.             i++;  
  20.             for(int j=0;j<1000000;j++);  
  21.             System.out.println("i="+i);  
  22.         }  
  23.     }  
  24. }  
  25.   
  26. class MyRunnableB implements Runnable{  
  27.     public void run(){  
  28.         char c='A'-1;  
  29.         while(c<'Z'){  
  30.             c++;  
  31.             for(int j=0;j<1000000;j++);  
  32.             System.out.println("c="+c);  
  33.         }  
  34.     }  
  35. }  

 

Java代码   收藏代码
  1. package thread.test04;  
  2.   
  3. import java.util.concurrent.Callable;  
  4. import java.util.concurrent.ExecutionException;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.Future;  
  8.   
  9. public class ThreadTestB {  
  10.     public static void main(String[] args) {  
  11.         ExecutorService e=Executors.newFixedThreadPool(10);  
  12.         Future f1=e.submit(new MyCallableA());  
  13.         Future f2=e.submit(new MyCallableA());  
  14.         Future f3=e.submit(new MyCallableA());        
  15.         System.out.println("--Future.get()....");  
  16.         try {  
  17.             System.out.println(f1.get());  
  18.             System.out.println(f2.get());  
  19.             System.out.println(f3.get());            
  20.         } catch (InterruptedException e1) {  
  21.             e1.printStackTrace();  
  22.         } catch (ExecutionException e1) {  
  23.             e1.printStackTrace();  
  24.         }  
  25.           
  26.         e.shutdown();  
  27.           
  28.     }  
  29.   
  30. }  
  31.   
  32. class MyCallableA implements Callable<String>{  
  33.     public String call() throws Exception {  
  34.         System.out.println("开始执行Callable");  
  35.         String[] ss={"zhangsan","lisi"};  
  36.         long[] num=new long[2];  
  37.         for(int i=0;i<1000000;i++){  
  38.             num[(int)(Math.random()*2)]++;  
  39.         }  
  40.           
  41.         if(num[0]>num[1]){  
  42.             return ss[0];  
  43.         }else if(num[0]<num[1]){  
  44.             throw new Exception("弃权!");  
  45.         }else{  
  46.             return ss[1];  
  47.         }  
  48.     }  
  49.       
  50. }  

 来源: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() {}
}

 

分享到:
评论

相关推荐

    使用Runnable模拟Callable接口实现线程有返回值

    大家都知道Runnable和Callable接口都可以作为其他线程执行的任务,但是Runnable接口的run方法没有返回值,而Callable接口的call方法有返回值,那么Callable接口是如何做到的呢?在此我给出一个Demo,看看通过...

    Java中的Callable接口最全讲义

    Callable接口的基本用法 2.1 创建Callable任务 2.2 提交Callable任务 2.3 获取任务执行结果 Future接口的使用 3.1 获取任务执行状态 3.2 取消任务的执行 Callable与Runnable的对比 Callable的异常处理 Callable的...

    Java多线程Callable接口

    Runnable是执行工作的独立任务,但是它不返回任何值,如果你希望任务在完成时能够返回一个值,那么可以实现Callable接口而不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型,它的类型参数表示...

    java自定义任务类定时执行任务示例 callable和future接口使用方法

    Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务

    【多线程高并发编程】三 Callable源码分析

    程序猿学社的GitHub,欢迎Star ...本文已记录到github,形成...源码分析2.1 第一步,实现Callable接口2.2 FutureTask类结构图2.3 RunableFuture接口2.4 Runnable接口2.5 Future接口2.6 FutureTask源码分析后记 前言 通过上

    这就是标题—— JUC.pdf

    Callable接口 线程创建的方式 callable / runnable FutureTask JUC常用辅助类 CountDownLatch (减少计数器) CyclicBarrier(加法计数器) Semaphore(信号量,流量控制) ReentrantReadWriteLock (读写锁) ...

    突破JAVA万人面试,懂多线程者得天下.zip

    05线程创建实现 Runnable接口avi 06线程创建实现 Callable接口avi 07线程创建线程池创建线程avi 08线程创建小结av 09线程生命周期avi 10.线程安全问题什么是线程安全avi 11线程安全同题问题分析avi 12线程安全问题...

    创建线程的四种方式?

    1,继承Thread类(底层 Thread类也实现了 Runnable接口) class MyThread extends Thread 2,实现Runnable接口 class MyThread implements Runnable 3,(JDK1.5以后)实现Callable接口 4,使用线程池 面试题: 说说...

    线程池之Executor框架.docx

    包括被执行任务需要实现的接口:Runnable接口或者Callable接口。 任务的执行 。包括任务执行机制的核心接口Executor,以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService...

    java多线程学习

    java多线程学习,常见实现线程的方式,继承Thread类,实现Runnable接口,实现Callable接口

    多线程学习笔记.docx

    包括线程和进程的关系,线程的三种创建方式,继承thread,实现runnable接口,实现callable接口,线程同步,生产者消费者模式

    \java超强笔记(超级经典)

    Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。Callable和Runnable有几点不同: Callable规定的方法是call(),而Runnable规定的方法是run(). ...

    什么是线程,线程是什么

    2、创建一个类并实现Runnable接口,重写run()方法,创建实现Runnable接口的类的对象,将该对象当做Thread类的构造方法中的参数传进去; 3、实现Callable接口,创建一个类并实现Callable接口,重写call()方法,将所要...

    线程超时死掉

    不直接构造Future对象,也可以使用ExecutorService.submit方法来获得Future对象,submit方法即支持以 Callable接口类型,也支持Runnable接口作为参数,具有很大的灵活性。使用示例如FutureTaskAndExcutor中的limit...

    深入理解高并发编程-Java线程池核心技术

    java并发编程实战pdf 线程与多线程 1.线程 在操作系统中,线程是比进程更小的能够独立运行的基本单位。同时,它也是 CPU 调度的基本单位。...Runnable 接口,实现 Callable 接口。简单的示例代码分别如下所示。

    Java多线程实现四种方式原理详解

    2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建线程 前面两种可以归结为一类:无返回值,原因很简单,...

    java线程学习笔记

    1.4 任务中返回值Callable接口 3 1.5 休眠 6 1.6 让步 6 1.7 优先级 6 1.8 后台线程(daemon) 6 1.9 加入线程(join) 8 1.10 捕获异常(UncaughtExceptionHandler) 9 1.11 线程与任务 10 1.12 让后计算 11 二 ...

    java面试题.docx

    接口和抽象类有什么区别? Files的常用方法都有哪些? java 容器都有哪些? List、Set、Map 之间的区别是什么? Collection 和 Collections 有什么区别? HashMap 和 Hashtable 有什么区别? 说一下 HashMap 的...

    java多线程Future和Callable类示例分享

    JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。今天我们...

    阿里2021届Java开发实习面经

    3.实现Callable接口,使用FatureTask包装该对象并作为Thread参数 买家要看到自己买的订单, 卖家要看到自己卖的订单, 怎么设计数据库 不会 mysql存储引擎 对于MySQL 5.5及更高版本,默认的存储引擎是Inn

Global site tag (gtag.js) - Google Analytics