精华内容
下载资源
问答
  • Callable

    2019-08-30 11:26:58
    通过实现Callable接口开启一个分线程 第一步 创建一个类并实现Callable接口 第二步 重写call方法并返回数据 第三步 创建Callable实现类的对象 第四步 创建FutureTask对象,并将Callable实现类的对象作为参数传递到...

    通过实现Callable接口开启一个分线程

    第一步 创建一个类并实现Callable接口
    第二步 重写call方法并返回数据
    第三步 创建Callable实现类的对象
    第四步 创建FutureTask对象,并将Callable实现类的对象作为参数传递到FutureTask的构造器中
    第五步 创建Thread对象并将FutureTask对象作为参数传递Thread的构造器中
    第六步 调用Thread的start方法
    第七步 调用FutureTask中的get()方法获取返回值

    public static void main(String[] args) throws Exception, Exception {
    	//第三步  创建Callable实现类的对象
    	MyCallble myCallble = new MyCallble();
    	//第四步  创建FutureTask对象,并将Callable实现类的对象作为参数传递到FutureTask的构造器中
    	FutureTask<String> futureTask = new FutureTask<>(myCallble);
    	//第五步 创建Thread对象并将FutureTask对象作为参数传递Thread的构造器中
    	Thread thread = new Thread(futureTask);
    	//第六步  调用Thread的start方法
    	thread.start();
    	//第七步  调用FutureTask中的get()方法获取返回值
    	String str = futureTask.get(); //get方法(阻塞式的)后的代码都是在分线程执行完毕后再开始执行的
    	System.out.println(str);
    	
    	for (int i = 0; i < 50; i++) {
    		System.out.println(Thread.currentThread().getName() + "   " + i);
    	}
    }
    
    }
    
    
    // 第一步  创建一个类并实现Callable接口
    class MyCallble implements Callable<String>{
    
    	// 第二步 重写call方法并返回数据
    	@Override
    	public String call() throws Exception {
    		
    		for (int i = 0; i < 50; i++) {
    			System.out.println(Thread.currentThread().getName() + "   " + i);
    		}
    		return "aaa";
    	}
    	
    }
    
    展开全文
  • Java线程(七):Callable和Future

    万次阅读 多人点赞 2016-02-05 15:12:04
    接着上一篇继续并发包的学习,本篇说明的是Callable和Future,它俩很有意思的,一个产生结果,一个拿到结果。 Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回...

           接着上一篇继续并发包的学习,本篇说明的是Callable和Future,它俩很有意思的,一个产生结果,一个拿到结果。
           Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable功能更强大一些,被线程执行后,可以返回值,这个返回值可以被Future拿到,也就是说,Future可以拿到异步执行任务的返回值,下面来看一个简单的例子:

    public class CallableAndFuture {
    	public static void main(String[] args) {
    		Callable<Integer> callable = new Callable<Integer>() {
    			public Integer call() throws Exception {
    				return new Random().nextInt(100);
    			}
    		};
    		FutureTask<Integer> future = new FutureTask<Integer>(callable);
    		new Thread(future).start();
    		try {
    			Thread.sleep(5000);// 可能做一些事情
    			System.out.println(future.get());
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} catch (ExecutionException e) {
    			e.printStackTrace();
    		}
    	}
    }
    

           FutureTask实现了两个接口,Runnable和Future,所以它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值,那么这个组合的使用有什么好处呢?假设有一个很耗时的返回值需要计算,并且这个返回值不是立刻需要的话,那么就可以使用这个组合,用另一个线程去计算返回值,而当前线程在使用这个返回值之前可以做其它的操作,等到需要这个返回值时,再通过Future得到,岂不美哉!这里有一个Future模式的介绍:http://openhome.cc/Gossip/DesignPattern/FuturePattern.htm。
           下面来看另一种方式使用Callable和Future,通过ExecutorService的submit方法执行Callable,并返回Future,代码如下:

    public class CallableAndFuture {
    	public static void main(String[] args) {
    		ExecutorService threadPool = Executors.newSingleThreadExecutor();
    		Future<Integer> future = threadPool.submit(new Callable<Integer>() {
    			public Integer call() throws Exception {
    				return new Random().nextInt(100);
    			}
    		});
    		try {
    			Thread.sleep(5000);// 可能做一些事情
    			System.out.println(future.get());
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} catch (ExecutionException e) {
    			e.printStackTrace();
    		}
    	}
    }
    

           代码是不是简化了很多,ExecutorService继承自Executor,它的目的是为我们管理Thread对象,从而简化并发编程,Executor使我们无需显示的去管理线程的生命周期,是JDK 5之后启动任务的首选方式。
           执行多个带返回值的任务,并取得多个返回值,代码如下:

    public class CallableAndFuture {
    	public static void main(String[] args) {
    		ExecutorService threadPool = Executors.newCachedThreadPool();
    		CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);
    		for(int i = 1; i < 5; i++) {
    			final int taskID = i;
    			cs.submit(new Callable<Integer>() {
    				public Integer call() throws Exception {
    					return taskID;
    				}
    			});
    		}
    		// 可能做一些事情
    		for(int i = 1; i < 5; i++) {
    			try {
    				System.out.println(cs.take().get());
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			} catch (ExecutionException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    } 
    

           其实也可以不使用CompletionService,可以先创建一个装Future类型的集合,用Executor提交的任务返回值添加到集合中,最后遍历集合取出数据,代码略。更新于2016-02-05,评论中就这个说法引发了讨论,其实是我没有讲清楚,抱歉。这里再阐述一下:提交到CompletionService中的Future是按照完成的顺序排列的,这种做法中Future是按照添加的顺序排列的。所以这两种方式的区别就像评论中fishjam**所描述的那样。

           本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/7451464,转载请注明。

    展开全文
  • tuple object is not callable解决方案

    万次阅读 多人点赞 2017-10-19 13:30:53
    在按照书上的代码操作的时候,有些时候会遇到一些很奇怪的bug,...解决之后发现问题也特别简单在python中,只有函数才是Callable(可Call的对象才是Callable)。但是tuple是一个数据类型,当然是不能Call(翻译成:使唤

    在按照书上的代码操作的时候,有些时候会遇到一些很奇怪的bug,标题就是一个这样的bug。
    操作实例的时候是用了shape函数
    为了解决这个bug,查了很多资料,都没有找到解决方案,最后不断尝试,并结合了一点经验解决了。
    解决之后发现问题也特别简单

    在python中,只有函数才是Callable(可Call的对象才是Callable)。但是tuple是一个数据类型,当然是不能Call(翻译成:使唤,hhh可能会比较容易理解)

    有bug的代码如下:

    from numpy import *
    a = array([[1, 3], [2, 4], [5, 6]])
    print(a.shape(0))
    

    要是能找到错误,就非常好了
    其实错误很简单
    正确的代码如下

    from numpy import *
    a = array([[1, 3], [2, 4], [5, 6]])
    print(a.shape[0])
    

    其实这个bug应该很容易发现才对,但是,最近打了很多matlab的文件()符号在MATLAB中就是[]的类似意思,所以找了很久。
    分享给大家,供大家一起学习
    觉得有点帮助就点个赞吧

    TypeError: ‘tuple’ object does not support item assignment解决方案 还有一个相关的文章,看可以放在一起看

    在这里插入图片描述

    展开全文
  • Callable和Future

    万次阅读 2021-03-10 17:48:21
    它们俩其实挺有意思,在运行的时候各司其职,Callable产生结果,Future获取结果。 使用步骤如下: 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值; 创建 ...

    它们俩其实挺有意思,在运行的时候各司其职,Callable产生结果Future获取结果

    使用步骤如下:

    1. 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值;
    2. 创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值;
    3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程;
    4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

    接下来通过一个示例来学习这两个对象的使用:

    public class Test {
        public static void main(String[] args) {
            CallableThreadTest cts = new CallableThreadTest();
            // 接收
            FutureTask<Integer> ft = new FutureTask<>(cts);
            new Thread(ft, "有返回值的线程").start();
            for (int i = 0; i < 30; i++) {
                System.out.println( "main" + " 的循环变量i的值:" + i);
            }
            try {
                System.out.println("子线程的返回值:" + ft.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    class CallableThreadTest implements Callable<Integer> {
        public Integer call() throws Exception {
            int i = 0;
            for (; i < 30; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            return i;
        }
    }
    

    运行这段程序你应该可以获取到类似如下结果(每次运行的结果不一致): ... ... main 的循环变量i的值:28 main 的循环变量i的值:29 有返回值的线程 23 有返回值的线程 24 有返回值的线程 25 有返回值的线程 26 有返回值的线程 27 有返回值的线程 28 有返回值的线程 29 子线程的返回值:30

    由于输出过长,省略了部分结果,可以发现在最后接收到了子线程的返回值。

    在实现Callable接口中,此时不再是run()方法了,而是call()方法,此call()方法作为线程执行体,同时还具有返回值!

    细心的你会发现这个结果是call函数的返回值,怎么拿到这个返回值的呢?是通过FutureTask拿到的,使用ft.get()方法即可获得线程的返回值,这就是一个简单的使用Callable和Future的过程了。

    展开全文
  • <div><p>Accessing Callable from collections is deprecated (should be from collections.abc), but simply calling callable works here.</p><p>该提问来源于开源项目:kurtmckee/feedparser</p></div>
  • 线程Callable写法

    2017-06-23 16:04:19
    Callable
  • Callable接口

    2021-01-24 22:23:27
    Callable接口详解 Callable: 返回结果并且可能抛出异常的任务。 优点: 可以获得任务执行返回值; 通过与Future的结合,可以实现利用Future来跟踪异步计算的结果。 Runnable和Callable的区别 1、Callable规定的...
  • Callable FutureTask

    2018-11-21 19:25:04
    Callable和FutureTask就实现了这一机制。 Callable和Runnable区别 区别 callable可以携带返回值,泛型 callable可以抛出异常 callable的方法名是call,runnable方法名是run 联系 callable本质...
  • 深入理解Callable

    万次阅读 2017-08-22 18:34:42
    概述Callable和Runnbale一样代表着任务,区别在于Callable有返回值并且可以抛出异常。其使用如下: public class CallableDemo { static class SumTask implements Callable<Long> { @Override public Long ...
  • Java Callable和Future在多线程编程中经常使用。在最后几篇文章中,我们学到了很多关于java线程的知识,但有时我们希望线程可以返回一些可以使用的值。Java 5在并发包中引入了java.util.concurrent.Callable接口,...
  • 如果我们希望任务完成之后有返回值,可以实现Callable接口。在JavaSE5中引入的Callable是一个具有类型参数的范型,他的类型参数方法表示为方法call()而不是run()中返回的值,并且必须使用ExecutorService.submint()...
  • Callable使用

    2018-02-01 18:40:40
    实现Callable接口的任务线程能返回执行结果,Callable接口的call()方法允许抛出异常。 注意点: Callable接口支持返回执行结果,此时需要调用FutureTask.get()方法实现,此方法会阻塞主线程直到获取‘将来’...
  • Callable 使用

    2018-05-27 16:54:00
    # Callable 使用 一、问题 继承 Thread 类或者实现 Runnable 接口,run()方法返回类型是void,即启动的线程任务无返回结果。 二、解决 实现 Callable 接口 public class TaskWithResult implements Callable<...
  • 手写Callable

    2019-08-09 19:24:25
    手写Callable 了解其运行原理 下面代码是我手写的一个实现callable的实现类。不谈具体实现了什么类容,重点是怎么让这个线程跑起来的。用了submit()方法。 看看源码里面到底是个什么鬼。 看一下submit()方法的源码 ...
  • callable接口

    2017-10-02 14:41:21
    callable接口和Runnable接口 相同点:两者都是接口,都可以编写多线程实现,两者都是调用Thread.start()启动。 不同点:实现Callable接口的任务线程能返回执行结果;而实现Runnable接口的任务线程不能返回结果; ...
  • Python错误:TypeError: 'int' object is not callable解决办法

    万次阅读 多人点赞 2018-07-24 22:06:46
    该错误的意思是Int型的对象是不可调用的(not callable)。 class User(): def __init__(self,name,age,number): self.name = name self.age = age self.custom = number def cust...
  • Java Callable

    2018-03-28 17:05:00
    接着上一篇继续并发包的学习,本篇说明的是Callable和Future,它俩很有意思的,一个产生结果,一个拿到结果。 Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果...
  • Callable实现

    2018-05-07 16:01:19
    1.接口的定义:public interface Callable&lt;V&gt; { V call() throws Exception; } 12342.Callable和Runnable的异同先看下Runnable接口的定义public interface Runnable { public abstract void run...
  • 转自:快递小可Python callable() 函数描述python中的内建函数callable( ), 可以检查一个对象是否是可调用的 。对于函数, 方法, lambda 函数式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True.>>> ...
  • callable线程池示例Java Callable and Future are used a lot in multithreaded programming. In last few posts, we learned a lot about java threads but sometimes we wish that a thread could return some ...
  • Runnable与Callable

    2020-10-18 15:41:12
    Runnable与Callable 接口定义 //Callable接口 public interface Callable<V> { V call() throws Exception; } //Runnable接口 public interface Runnable { public abstract void run(); } Callable的使用...
  • Callable Feature

    2017-08-31 19:19:25
       接着上一篇继续并发包的学习,本篇说明的是Callable和Future,它俩很有意思的,... Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable
  • 面向对象程序设计 并发 主讲人何鑫 软件技术专业教学资源库 Callable和Future 第十部分 Callable与Future之间的关系 1Callable用法和Runnable类似只不过调用的是call)方法而不是run)方法该方法有一个泛型返回值类型 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,282
精华内容 9,712
热门标签
关键字:

callable