Part 1: java.util.concurrent - Runnable Vs Callable in Java

About Runnable:
Runnable inte易做图ce is implemented by the Thread class as well and it's a common protocol for all the objects who wish to execute in a different thread. It's one of the ways of creating threads in Java. The other way to create a thread is by subclassing the Thread class. A class implementing Runnable inte易做图ce can simply pass itself to create a Thread instance and can run thereafter. This eliminates the need of subclassing the Thread class for the purpose of executing the code in a separate thread.
As long as we don't wish to override other methods of the Thread class, it may be a better idea to implement the Runnable inte易做图ce to enable multithreading capabilities to a class than enabling the same by extending the Thread class.

About Callable:
The designers of Java felt a need of extending the capabilities of the Runnable inte易做图ce, but they didn't want to affect the uses of the Runnable inte易做图ce and probably that was the reason why they went for having a separate inte易做图ce named Callable in Java 1.5 than changing the already existing Runnable inte易做图ce which has been a part of Java since Java 1.0.

Similarities:
1) Both threads can be used to cause a separate stack for a thread.

2) Both has only one method : Inside Runnable it is called as
public abstract void run( );
Inside callable the method is being called as
public abstract call() ;
(Note : V can be any valid object in JAVA)

Differences:

1) Return Type -
public abstract void run() --> Return type "void"
public abstract call() --> Return type "Any valid JAVA Object"

2) Run method can not throw any checked Exception, whereas
public abstract call() throw checkedException
Call method can throw any checked Exception.

package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
* This program has been written to demonstrate the usage
* of Runnable and Callable<String> Inte易做图ces. Jovial Java makes
* no guarantee of any harm or any problem caused by using this
* program.
*/
public class Run_Vs_Call {


    public static void main(Stringargs){
        CallableTask call = new CallableTask();
        RunnableTask run = new RunnableTask();
        try{
            /*
             * We need a Future task Launcher to launch Callable Class
             */
            FutureTask<String> callTask = new FutureTask<String>(call);
            /*
             * We need a Thread Launcher to to launch Runnable Class
             */
            Thread runTask = new Thread(run);
            callTask.run();
            runTask.start();

            /*
             * Get is a blocking call, JVM will wait here until Call task
             * finishes execution.
             */
            System.out.println(callTask.get());


        }catch(Exception e){
            e.printStackTrace();
        }

    }

    /*
     *Callable<V> is defined as Callable<String>
     *
     */
    public static class CallableTask implements Callable<String>{

        public String call( ){
            System.out.println("Inside call method..!!");
            return "hello";
        }
    }
    /*
     * Runnable Inte易做图ce Implementation
     */
    public static class RunnableTask implements Runnable{
        public void run(){
            System.out.println("Inside Run Method, I can not return any thing");
        }
    }

}
作者：ゞ沉默是金ゞ

补充：软件开发 , Java ,