精华内容
下载资源
问答
  • runnable和callable区别

    2020-02-17 11:29:19
    runnable和callable区别 接口定义: callable public interface Callable<V> { V call() throws Exception; } runnable public interface Runnable { public abstract void run(); } 相同点: 都是接口...

    runnable和callable区别

    接口定义:

    callable

    public interface Callable<V> {
        V call() throws Exception;
    }
    

    runnable

    public interface Runnable {
        public abstract void run();
    }
    
    

    相同点:

    1. 都是接口,都无法实例化。
    2. 都可以用来进行线程任务创建。
    3. 都可以提交线程池。

    不同点:

    1. callable可以有返回值,runnable没有返回值。
    2. callable的call()可以抛出异常,runnable的run()不可以。
    3. runnable支持Thread构建,callable不支持。
    展开全文
  • Runnable 和Callable区别

    千次阅读 2018-05-06 15:43:55
    Java 提供了三种创建线程的...通过Callable和Future创建线程 通过实现 Runnable 接口来创建线程 public class RunnableDemo { public static void main(String[] args) { new Thread(new MyThr...

    Java 提供了三种创建线程的方法

    1. 通过实现Runnable接口
    2. 通过继承Thread接口
    3. 通过Callable和Future创建线程

    通过实现 Runnable 接口来创建线程

    public class RunnableDemo {
        public static void main(String[] args) {
            new Thread(new MyThread(),"线程1").start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    
                }
            },"线程2").start();
        }
    }
    
    /**
     * 实现 Runnable 接口的线程类
     */
    class MyThread implements Runnable{
    
        /** 
         * 重写run方法
         */
        @Override
        public void run() {
            // TODO Auto-generated method stub
            
        }
    }
    

    通过继承Thread类

    public class ThreadDemo {
        public static void main(String[] args) {
            new MyThread().start();
            new Thread(new MyThread(), "线程2").start();
        }
    }
    class MyThread extends Thread{
    
        /** 
         * 重写run方法
         */
         @Override
         public void run() {
             // TODO Auto-generated method stub
             super.run();
         }
    }
    

    通过Callable和Future创建线程

    public class FutureDemo {
        public static void main(String[] args) {
            //创建 Callable 实现类的实例
            MyCallable myCallable = new MyCallable();
            //使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值
            FutureTask<String> futureTask = new FutureTask<String>(myCallable);
            String res = null;
            try {
                //使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程
                //没这句,下句代码获取不到结果,会一直等待执行结果
                new Thread(futureTask,"线程1").start();
                //调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值
                res = futureTask.get();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(res);
        }
    }
    /**
     * 创建 Callable 接口的实现类,并实现 call() 方法
     */
    class MyCallable implements Callable<String>{
    
        /** 
         * 该 call() 方法将作为线程执行体,并且有返回值
         */
        @Override
        public String call() throws Exception {
            return "success";
        }
    }
    

    Runnable 和Callable区别

    方法名 ExecutorService的执行方法 ExecutorService.submit()返回值 返回的Future调用get()方法 线程体 取消执行
    Runnable execute和submit Future null run() 不能
    Callable 只能是submit Future Future定义的泛型T call() Future.cancel能取消执行
    展开全文
  • Runnable和Callable区别

    2019-04-25 11:00:24
    面试问区别,我说不知道,感觉空气瞬间突然宁静了。。。内心555 话不多说,吃一堑长一智!!!Runnable接口: public interface Runnable { public abstract void run(); } Callable接口: public ...

    面试问区别,我说不知道,感觉空气瞬间突然宁静了。。。内心555
    话不多说,吃一堑长一智!!!
    Runnable接口:

     

    public interface Runnable {
        public abstract void run();
    }
    

    Callable接口:

     

    public interface Callable<V> {
        V call() throws Exception;
    }


    相同点:

    1. 两者都是接口。。。。。。。。            (  额,可以忽略。。。)
    2. 都可用来编写多线程程序;                       (忽略三连,2333)
    3. 两者都需要调用Thread.start()启动线程;  (说正事)

     

    不同点:

    1. 两者最大的不同点是:
      实现Callable接口的任务线程能返回执行结果;
      实现Runnable接口的任务线程不能返回结果(void);
    2. Callable接口的call()方法允许抛出异常;
      而Runnable接口的run()方法的异常不能继续上抛;

     

    展开全文
  • Runnable和Callable区别与联系 接口定义 Runnable接口 public interface Runnable { void run(); } Callable接口 public interface Callable<V> { V call() throws Exception; } 联系 都是接口 都可以...

    Runnable和Callable区别与联系

    接口定义

    Runnable接口
    public interface Runnable {
        void run();
    }
    
    Callable接口
    public interface Callable<V> {
        V call() throws Exception;
    }
    

    联系

    1. 都是接口
    2. 都可以编写多线程程序
    3. 都采用Thread.start()启动线程

    区别

    1. Runnable执行方法是run();Callable是call()
    2. Runnable的run方法无返回值;Callable是个支持泛型的接口,它的call方法提供返回值用来表示任务运行的结果,返回值是个泛型,和Future、FutureTask配合可以用来获取异步执行的结果
      :Callable接口支持返回执行结果,需要调用FutureTask.get()得到,此方法会阻塞主进程的继续往下执行,如果不调用不会阻塞。
    3. Runnable提供run方法,不可以抛出异常,若有异常,只能在run方法内部处理异常;Callable提供call方法,直接抛出Exception异常,也就是你不会因为call方法内部出现检查型异常而不知所措,完全可以抛出即可。
    4. Runnable可以作为Thread构造器的参数,通过开启新的线程来执行,也可以通过线程池来执行;而Callable只能通过线程池执行。

    Callable使用

    因为Callable的call方法提供返回值,所以当你需要知道任务执行的结果时,Callable是个不错的选择。
    如下是个简单例子,Callable任务返回0到520整数之和。

    class IntegerCallableTask implements Callable<Integer> {
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 520; i++) {
                sum += i;
            }
            return sum;
        }
    }
    

    Callable任务通过线程池的submit方法提交。且submit方法返回Future对象。

    1. Future 提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。
      计算完成后只能使用 get 方法来获取结果,如果线程没有执行完,Future.get()方法可能会阻塞当前线程的执行;如果线程出现异常,Future.get()会throws InterruptedException或者ExecutionException;如果线程已经取消,会跑出CancellationException。
    2. 取消由cancel 方法来执行。
    3. isDone确定任务是正常完成还是被取消了。一旦计算完成,就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果,则可以声明Future<?> 形式类型,并返回 null 作为底层任务的结果。
     // 创建一个执行任务的服务
            ExecutorService executor = Executors.newFixedThreadPool(3);
            try {
                // 1.Callable通过Future能返回结果
                // 提交并执行任务,任务启动时返回了一个 Future对象
                // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
                Future<String> future1 = executor.submit(new Callable<String>() {
                    public String call() throws Exception {
                        // TODO Auto-generated method stub
                        return "result=task1";
                    }
                });
                // 获得任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行
                System.out.println("task1: " + future1.get());
    
                //2. 对Callable调用cancel可以对对该任务进行中断
                // 提交并执行任务,任务启动时返回了一个 Future对象
                // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
                Future<String> future2 = executor.submit(new Callable<String>() {
                    public String call() throws Exception {             
                        try {
                            while (true) {
                                System.out.println("task2 running.");
                                Thread.sleep(50);
                            }
                        } catch (InterruptedException e) {
                            System.out.println("Interrupted task2.");
                        }
                        return "task2=false";
                    }
                });
    
                // 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环
                Thread.sleep(10);
                System.out.println("task2 cancel: " + future2.cancel(true));
    
                // 3.用Callable时抛出异常则Future什么也取不到了
                // 获取第三个任务的输出,因为执行第三个任务会引起异常
                // 所以下面的语句将引起异常的抛出
                Future<String> future3 = executor.submit(new Callable<String>() {
                    public String call() throws Exception {
                        throw new Exception("task3 throw exception!");
                    }
    
                });
                System.out.println("task3: " + future3.get());
            } catch (Exception e) {
                System.out.println(e.toString());
            }
            // 停止任务执行服务
            executor.shutdownNow();
        }
    

    Runnable使用

    1)由于Java只提供单继承,故创建线程时一般通过实现Runnable接口,来重写run方法的具体逻辑。然后实例化,作为Thread的构造参数开启线程。

    //自定义类  实现Runnable
    class MyThread implements Runnable{
    	public void run() {
    		for(int i = 0;i < 10;i ++) {
    			//获取当前正在执行的线程
    			Thread t =Thread.currentThread();
    		System.out.println(t.getName() + ":" + i);
    		}
    	}
    }
    

    main方法:

    Thread t = new Thread(new MyThread());
    t.start();
    

    2)作为Thread的构造参数开启新的线程,以下是常用的通过匿名内部类的方式创建线程。

     //匿名内部类
    Thread t = new Thread(new Runnable() { 
    			public void run() {
    				for(int i=0;i<10;i++) {
    				Thread t =Thread.currentThread();
    				System.out.println(t.getName()+":"+i);
    				}
    			}
    		});
    		t.start();
    

    3)作为线程任务提交给线程池,通过线程池维护的工作者线程来执行。

    // ExecutorService 线程池服务
    // newFixedThreadPool  创建指定线程个数的线程池
    ExecutorService exe = Executors.newFixedThreadPool(2);
    		for(int i = 0;i<10; i++) {
    			//每一次循环,创建一个线程任务
    			Runnable run =new Runnable() {
    				public void run() {
    					Thread thread = Thread.currentThread();
    					System.out.println(thread.getName()+"run");
    				}
    			};
    			//将所有的线程任务交给线程池来完成
    			exe.execute(run);
    		}
    		//关闭线程池
    		exe.shutdown();
    
    展开全文
  • 多线程编程优点 进程之间不能共享内存,但线程之间共享内存非常容易。... 实现Callable接口(参考&lt;Java编程思想(第4版)&gt; 21.2.4章节,原来一直以为是2种,后来发现是3种) 回到顶部 第...
  • 3. Thread thread = new Thread(new Runnable() { 4. @Override 5. public void run() { 6. long startTime = System.currentTimeMillis(); 7. for (int i=0;i<1000000;i++){ 8. //判断当前线程的状态是否已经...
  • Runnable和Callable区别

    千次阅读 2019-03-04 11:14:14
    Runnable和Callable区别Runnable和Callable区别:ExcutorService中的excutor和submit方法的区别使用场景:FutureTask:ExecutorCompletionService:示例代码:使用CompletionService维护结果:自己创建list维护...
  • java中Runnable和Callable区别

    万次阅读 2020-03-11 09:18:36
    java中Runnable和Callable区别 在java的多线程开发中Runnable一直以来都是多线程的核心,而Callable是java1.5添加进来的一个增强版本。 本文我们会详细探讨Runnable和Callable区别。 运行机制 首先看下Runnable...
  • Runnable , Callable 区别

    2017-04-22 13:38:14
    编写多线程程序是为了...Runnable和Callable区别是, (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值得 (3)call方法可以抛出异常,
  • 编写多线程程序一般有三种方法,Thread,Runnable,Callable.Runnable和Callable区别是:Callable规定的方法是call(),Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下,直接启动一个线程来执行,...
  • runnable callable 有什么区别: 1.Runnable接口中的run()方法的返回值是void,它做的事情只是纯粹地去执行run()方法中的代码而已 2.Callable接口中的call()方法是有返回值的,是一个泛型,Future、FutureTask...
  • 编写多线程程序一般有三种方法,Thread,Runnable,Callable.Runnable和Callable区别是:(1)Callable规定的方法是call(),Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下,直接启动一个线程来...
  • Runnable和Callable区别和联系

    万次阅读 多人点赞 2018-08-20 22:37:30
    Java多线程有两个重要的接口,Runnable和Callable,分别提供一个run方法和call方法,二者是有较大差异的。 1)Runnable提供run方法,无法通过throws抛出异常,所有CheckedException必须在run方法内部处理。Callable...
  • RunnableCallable区别: (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的 (3)call方法可以抛出异常,run方法不可以 (4)运行...
  • Java中Runnable和Callable区别 Runnable和Callable区别是,(1)Callable规定的方法是call(),Runnable规定的方法是run().(2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值得(3)call...
  • Runnable和Callable区别  01.Runnable接口中只有一个run()没有返回值 没有声明异常 Callable接口中只有一个call()有返回值 有声明异常  02.Callable中的call()返回值我们一般使用Future接口来接收  03....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,102
精华内容 440
关键字:

runnable和callable区别