展开

关键词

Callable接口

如果希望任务在完成时能够返回一个值,那么可以实现Callable 接口而不是 Runnable 接口。 在 Java SE5 中引入的 Callable 是一个具有类型参数的泛型,它的类型参数表示的是从方法 call() 中返回的值 必须使用ExecutorService.submit() 方法调用实现Callable 接口的类的对象 submit方法会产生Future对象,它用Callable返回结果的类型进行了参数化。 示例import java.util.ArrayList;import java.util.concurrent.*; ** * Callable+Future使用示例 * User: pengyapan 0; i < 10; i++){ results.add(executorService.submit(new TaskWithResult(i))); submit方法会产生Future对象,它用Callable

11510

Callable and Future in Java(java中的Callable和Future)

为了之处这个特性,在java中就增加了Callable接口。 Callable vs Runnable为了实现Runnable接口,需要实现不返回任何返回值的run方法,而对于callable,我们需要实现在完成的时候,返回接口的call方法,注意,线程不能用Callable 需要注意的是,Callable和Future做了两件不同的事情,Callable和Runnable类似,因为它封装了一个任务,该任务在另外一个线程上运行,而Future用于存储从另外一个线程获得的结果, FutureTask可以通过为其提供的构造函数来创建Callable,然后将FutureTask对象提供给Thread的构造函数来创建Thread对象。因此,间接的实现了Callable创建线程。 在此要重点强调的是,没有办法直接用Callable创建线程。

13230
  • 广告
    关闭

    腾讯云前端性能优化大赛

    首屏耗时优化比拼,赢千元大奖

  • 您找到你想要的搜索结果了吗?
    是的
    没有找到

    python callable()方法

    callable(object)该函数的作用是检查对象object是否可调用。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。 >>> callable(0)False>>> callable(mystring)False>>> def add(a, b):… return a + b…>>> callable(add)True >>> class A:… def method(self):… return 0…>>> callable(A)True>>> a = A()>>> callable(a)False>>> class B:… def __call__(self):… return 0…>>> callable(B)True>>> b = B()>>> callable(b)True实际上我们可以自己实现callable 方法:def callable(object): return hasattr(object,__call__)

    21420

    python: callable函数

    API callable(object) 检查对象object是否可调用。 如果返回True,object仍可能调用失败; 如果返回False,object一定调用失败。 实验代码assert callable(0) == Falseassert callable(Hello Python) == False def add(a, b): return a + bassert callable(add) == True class A: def method(self): return 0assert callable(A) == Truea = A()assert callable (a) == False class B: def __call__(self): return 0assert callable(B) == Trueb = B()assert callable(b)

    38320

    Java并发之Executor + Callable + Future引入 Callable + FutureCallable + Future实例

    引入 Callable + FutureCallable + Future实例引入 Callable + FutureExecutor框架的优势之一就是,可以运行并发任务并且返回结果。 这个接口就是 Callable接口:这个接口声明了一个call方法,类似于Runnable接口的run方法,是任务具体的逻辑,不同就在于可以有返回值,而且这个接口是一个泛型接口,这就意味着必须声明call 我们任务交给线程执行之后,什么时候执行结束,将结果返回这个时间往往是无法具体确定的,所以为了接受这个来自未来某个时刻执行完之后的返回结果,又新增了一个Future接口: Future接口:这个接口声明了一些方法获取由callable image.pngCallable + Future实例接下来,我们编写一个实例来接受任务的返回结果实现一个Callable对象,由于返回值是Integer,所以定义为Callablepackage CreateExecutorCallableFuture java.util.concurrent.Callable;import java.util.concurrent.TimeUnit; public class FactorialCaculator implements Callable

    17730

    Python - typing 模块 —— Callable

    返回True或False栗子# 最简单的函数def print_name(name: str): print(name) # 判断函数是否可调用print(isinstance(print_name, Callable Callable 的源码Callable type; Callable, str] is a function of (int) -> str.第一个类型(int)代表参数类型第二个类型(str)代表返回值类型栗子 def print_name(name: str): print(name) # Callable 作为函数参数使用,其实只是做一个类型检查的作用,检查传入的参数值 get_func 是否为可调用对象def def get_name_test(func): return func vars2 = get_name_test(print_name)vars2(小菠萝) # 输出结果test小菠萝Callable 作为函数返回值# Callable 作为函数返回值使用,其实只是做一个类型检查的作用,看看返回值是否为可调用对象def get_name_return() -> Callable, None]: return

    8930

    Callable与Future介绍

    不过,Java中,也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务,产生结果,而Future用来获得结果。 Callable位于java.util.concurrent包下,它也是一个接口,在它里面也只声明了一个方法,只不过这个方法叫做call()。 public interface Callable { ** * Computes a result, or throws an exception if unable to do so. * * @return public static void main(String args) throws Exception{ Callable callable = new CallableService(); FutureTask (线程返回值: + task.get()); }} class CallableService implements Callable { @Override public Integer call(

    13610

    43.python callable函数

    python内置函数 callable用于检查一个对象是否是可调用的,如果函数返回True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。 一.callable函数简介语法如下:callable(object)参数介绍:object : 调用的对象;返回值:返回bool值,如果object对象可以被调用返回true,不能被调用返回false 二.callable函数使用# ! def test(func):    # 判断func如果是函数,就执行他,如果不是函数,直接返回    # 判断func是否可调用,如果可以调用,就是true    if callable(func)

    27710

    Future和Callable学习

    而实现多线程的三种方式:继承Thread;实现Runnable接口,重写run方法;实现Callable接口,同时重写call方法,同时通过Future获取执行的返回值。 也就是说callable执行任务,而Future拿到执行的结果。Future具有阻塞性在于其get()方法具有阻塞性,而isDone()是不具有阻塞性的。 如果需要返回结果,同时需要进一步加工的时候,就可以考虑使用Future+Callable了。 ,返回一个执行检查的异常信息,而Runnable返回的是void, * 因此在程序上方便排查问题,同时了解执行的结果情况,如果返回的结果想是void的,则可以在实现时选择 * Callable * * submit不仅可以传入Callable对象, * 也可以传入Runnable对象,说明submit()方法支持有返回值和无返回值的功能 * get具有阻塞性,而isDone不阻塞 * Callable

    14720

    Callable和Supplier的区别

    Callable is A task that returns a result, while a Supplier is a supplier of results. In other words a Callable is a way to reference a yet-unrun unit of work, while a Supplier is a way to reference a yet-unknown value.Its possible that a Callable could do very little work and simply return much concern about how much work that might take.Another way of phrasing the distinction is that a Callable If the work is idempotent use a Supplier, if not use a Callable.摘自https:softwareengineering.stackexchange.comquestions254311what-is-the-difference-between-callablet-and-java

    38920

    Java线程(七):Callable和Future

    接着上一篇继续并发包的学习,本篇说明的是Callable和Future,它俩很有意思的,一个产生结果,一个拿到结果。         Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable功能更强大一些,被线程执行后,可以返回值,这个返回值可以被 ExecutorService threadPool = Executors.newSingleThreadExecutor(); Future future = threadPool.submit(new Callable ExecutorCompletionService(threadPool); for(int i = 1; i < 5; i++) { final int taskID = i; cs.submit(new Callable

    28800

    简单理解Callable接口

    Callable接口:  Callable,新启线程的一种方式,返回结果并且可能抛出异常的任务,在前面的新启线程的文章中用过,但是没有具体讲解  优点:    可以获取线程的执行结果,也称为返回值     通过与Future的结合,可以实现利用Future来跟踪异步计算的结果Runnable和Callable的区别:  Callable规定的方法是call(),Runnable规定的接口是run();   Callable的任务执行后可返回值,而Runnable的任务是不能有返回值的;  call方法可以抛出异常,run方法不可以  运行Callable任务可以拿到一个Future对象,表示异步计算的结果 的两种执行方式 * @author ZYGisComputer *public class UseCallable { ** * 实现Callable接口的线程 * private static class (callable子线程开始执行任务计算); Thread.sleep(2000); for (int i = 0; i < 5000; i++) { sum += i; } System.out.println

    20451

    (八)Callable和Runnable的区别

    Callable和Runnable都是一个接口。 main(String args) { new ThreadPoolALL2().ExecutorThreadPool(); } static class TestCallable implements Callable 第 + count + 次); if (count == 2) { throw new RuntimeException(Callable 任务出错了); } return finish; } } public submit 和 execute的区别 execute执行的是一个Runnable任务,submit 执行 Runnable和Callable都可以。 Callable一般都是提交给ExecuteService来执行,核心方法是call(),通过submit方法执行。Runnable执行没有返回;Callable有返回。

    11410

    java中Runnable和Callable的区别

    java中Runnable和Callable的区别在java的多线程开发中Runnable一直以来都是多线程的核心,而Callable是java1.5添加进来的一个增强版本。 本文我们会详细探讨Runnable和Callable的区别。 所以Runnable可以通过Runnable和之前我们介绍的ExecutorService 来执行,而Callable则只能通过ExecutorService 来执行。 返回值的不同根据上面两个接口的定义,Runnable是不返还值的,而Callable可以返回值。 Callable的Call()方法抛出了throws Exception,所以可以在call()方法的外部,捕捉到Checked Exception。我们看下Callable中异常的处理。

    27840

    Java多线程之Callable和Future

    本篇说明的是Callable和Future,它俩很有意思的,一个产生结果,一个拿到结果。 Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable功能更强大一些,被线程执行后,可以返回值,这个返回值可以被 ExecutorService threadPool = Executors.newSingleThreadExecutor(); Future future = threadPool.submit(new Callable ExecutorCompletionService(threadPool); for(int i = 1; i < 5; i++) { final int taskID = i; cs.submit(new Callable

    22310

    Python的内置函数(四十二)、 callable()

    交流、咨询,有疑问欢迎添加QQ 2125364717,一起交流、一起发现问题、一起进步啊,哈哈哈哈哈 描述callable() 函数用于检查一个对象是否是可调用的。 语法callable()方法语法:callable(object)参数object -- 对象返回值可调用返回 True,否则返回 False。 实例以下实例展示了 callable() 的使用方法:>>>callable(0)False>>> callable(runoob)False >>> def add(a, b):... return a + b... >>> callable(add) # 函数返回 TrueTrue>>> class A: # 类... def method(self):... return 0... >>> callable __(self):... return 0... >>> callable(B)True>>> b = B()>>> callable(b) # 实现 __call__, 返回 TrueTrue

    18220

    Java中的Runnable、Callable、Future、FutureTask的区别

    FutureExecutor就是Runnable和Callable的调度容器,Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。 callable the callable task* @throws NullPointerException if the callable is null*public FutureTask(Callable callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state }可以看到,Runnable注入会被Executors.callable()函数转换为Callable类型,即FutureTask最终都是执行Callable类型的任务。 因此FutureTask既是Future、Runnable,又是包装了Callable(如果是Runnable最终也会被转换为Callable ), 它是这两者的合体。

    12730

    Java - Callable、Future、FutureTask说明及使用

    Callable、Future、FutureTask组合使用可以阻塞获取多线程执行的返回值,是Runnable功能的拓展。?1. 3000); Object o2 = futureTask.get(); System.out.println(o2); } public static class MyThread implements Callable UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { Callable c = callable; if (c ! = q.next; if (next == null) break; q.next = null; unlink to help gc q = next; } break; } } done(); callable

    13320

    多线程基础之RunnableThread与Callable

    String args) throws InterruptedException, ExecutionException { FutureTask task = new FutureTask( new Callable System.out.println(FutureTask处理结果: + task.get()); System.out.println(全部处理完成); }}二个注意点:a) FutureTask使用Callable

    55470

    PYES异常: TypeError: NoneType object is not callable

    usrlibpython2.7site-packagespyesconvert_errors.py, line 74, in raise_if_error bits = error.split([, 1)TypeError: NoneType object is not callable

    31780

    扫码关注云+社区

    领取腾讯云代金券