实现Callable接口
实现Callable接口,需要返回值类型
重写call方法,需要抛出异常
创建目标对象
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(t1);
获取结果:boolean r1 = result1.get()
关闭服务:se            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-04-25 09:29:00
                            
                                178阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            1:Callable实现类介绍 首先我们都知道,在Java中最常见的是继承Thread类和实现Runnable接口来实现多线程( 这里我推荐采用实现接口            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-06-27 20:22:07
                            
                                202阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            6.实现 Callable 接口前言本篇章来介绍一下创建线程的第三种方式,其中创建线程一共有四种方式:继承 Thread 类实现 Runnable 接口实现 Callable 接口使用线程...            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-07-01 18:54:21
                            
                                65阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            package CallableDemo;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import j            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-05-26 01:23:28
                            
                                104阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            前两篇博客(多线程——继承Thread类。多线程——实现Runnable接口 )介绍了java使用线程的两种方法。这篇博客继续介绍第三种方法——实现Callable接口。先说一下Runnable和Callable的差别:1、Callable规定的方法是call(),Runnable规定的方法是run...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2016-01-15 11:45:00
                            
                                144阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            runable可以看做是异步的没参数没返回值的一个线程任务,            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-07-19 16:27:02
                            
                                74阅读
                            
                                                                             
                 
                
                             
         
            
            
            
             
package com.app01;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import j            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                            精选
                                                        
                            2011-06-13 22:38:13
                            
                                327阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Callable和Future实现多线程        Future取得的结构类型和Callable返回的结果类型必须一致。      Callable要采用ExecutorService的submit方法提交,返回的future对象可以取消任务      &            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-07-06 13:44:05
                            
                                686阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Callable1、可以有返回值2、可以抛出异常3、方法不同,run()/call()代码测试import java.util.concurrent.Callable            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-02-01 10:08:04
                            
                                79阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            实现callable接口加泛型,即返回的值类型,默认为Object重写的call方法可以有返回值,可以抛出异常publicclassThreadDownloadimplementsCallable<Boolean>{publicBooleancall()throwsException{returntrue;}publicstaticvoidmain(String[]args)throw            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2019-08-07 09:25:09
                            
                                1049阅读
                            
                                                        
                                点赞
                            
                                                                             
                 
                
                             
         
            
            
            
            1 Callable 接口  Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式:Callable 接口  Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-01-05 22:21:00
                            
                                110阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            Runnable接口有个缺点,它的run方法没有返回值并且不能抛异常,如果需要线程执行完返回一个结果以及希望能抛出异常,那么还有一个接口刚好能弥补这两个缺点:Callable,它跟Runnable都是任务接口,使用上基本相同            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2020-09-25 16:15:00
                            
                                114阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            1、Callable1、可以有返回值2、可以抛出异常3、方法不同、run()/call()future Task细节:1、有缓            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-08-04 08:53:18
                            
                                68阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            多线程中 , 三种获得多线程的方式
1、继承Thread类2、实现Runnable接口3、实现 Callable接口
Callable与Runnable的区别
 //创建新类MyThread实现runnable接口
class MyThread implements Runnable{
 @Override
 public void run() {
 
 }
}
//新类MyThread2实            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-07-15 15:51:49
                            
                                128阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。 在Java5之前,线程是没有返回值的,常常为了“有”返回值,破费周折,而且代码很不好写。或者干脆绕过这道坎,走别的路了。现在Java终于有可返回值的任务(也可以叫做线程)了。 可返回值的任务必须实现Call            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2017-08-31 17:34:00
                            
                                84阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            Callable(简单)Callable 跟Runnable 的区别:Callable可以有返回值可以抛出异常方法不同,            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-09-22 09:39:30
                            
                                215阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Callable的两种实现方式 使用线程池 package com.edgar.lesson01; import java.util.concurrent.*; //创建线程方式:1.实现Callable类 2.重写call()方法 3.看main方法注释 public class TestCall ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-04-15 23:56:00
                            
                                508阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            实现步骤:
创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值。
创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
使用 FutureTask 对象作为 Thread 对象的 targe            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2019-08-13 17:04:00
                            
                                69阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Callable接口创建: 1,实现Callable接口,需要返回值类型 2,重写call方法,需要抛出异常 3,创建目标对象 4,创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(3); 5,执行提交:Future<Boolean> ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-08-18 13:35:00
                            
                                111阅读
                            
                                                                                    
                                2评论