Explore multithreading and concurrency concepts in Java, from the basics on upward.

Java for Programmers

Java Multithreading

## Callable Interface
In the previous sections we used the <code class="intf">Runnable</code> interface as the abstraction for tasks that were submitted to the executor service. The <code class="intf">Runnable</code> interface's sole <code class="mthd">run</code> method doesn't return a value, which is a handicap for tasks that don't want to write results to global or shared datastructures. The interface <code class="intf">Callable</code> allows such tasks to return results. Let's see the definition of the interface first.


```
public interface Callable<V> {
 /**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
 V call() throws Exception;
}
```

Note the interface also allows a task to throw an exception. A task goes through the various stages of its life which include the following:
<ul>
<li>created</li>
<li>submitted</li>
<li>started</li>
<li>completed</li>
</ul>

Let's say we want to compute the sum of numbers from 1 to n. Our task should accept an integer n and spit out the sum. Below are two ways to implement our task.


```java
 class SumTask implements Callable<Integer> {

 int n;

 public SumTask(int n) {
 this.n = n;
 }

 public Integer call() throws Exception {

 if (n <= 0)
 return 0;

 int sum = 0;
 for (int i = 1; i <= n; i++) {
 sum += i;
 }
 
 return sum;
 }
 }

```

Or we could take advantage of the anonymous class feature in the Java language to declare our task like so:


```java
 final int n = 10
 Callable<Integer> sumTask = new Callable<Integer>() {
 
 public Integer call() throws Exception {
 int sum = 0;
 for (int i = 1; i <= n; i++)
 sum += i;
 return sum;
 }
 };
```

Now we know how to represent our tasks using the <code class="intf">Callable</code> interface. In the next section we'll explore the <code class="intf">Future</code> interface which will help us manage a task's lifecycle as well as retrieve results from it.

# Callable Interface
In the previous sections we used the <code class="intf">Runnable</code> interface as the abstraction for tasks that were submitted to the executor service. The <code class="intf">Runnable</code> interface's sole <code class="mthd">run</code> method doesn't return a value, which is a handicap for tasks that don't want to write results to global or shared datastructures. The interface <code class="intf">Callable</code> allows such tasks to return results. Let's see the definition of the interface first.


```
public interface Callable<V> {
 /**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
 V call() throws Exception;
}
```

Note the interface also allows a task to throw an exception. A task goes through the various stages of its life which include the following:
<ul>
<li>created</li>
<li>submitted</li>
<li>started</li>
<li>completed</li>
</ul>

Let's say we want to compute the sum of numbers from 1 to n. Our task should accept an integer n and spit out the sum. Below are two ways to implement our task.


```java
 class SumTask implements Callable<Integer> {

 int n;

 public SumTask(int n) {
 this.n = n;
 }

 public Integer call() throws Exception {

 if (n <= 0)
 return 0;

 int sum = 0;
 for (int i = 1; i <= n; i++) {
 sum += i;
 }
 
 return sum;
 }
 }

```

Or we could take advantage of the anonymous class feature in the Java language to declare our task like so:


```java
 final int n = 10
 Callable<Integer> sumTask = new Callable<Integer>() {
 
 public Integer call() throws Exception {
 int sum = 0;
 for (int i = 1; i <= n; i++)
 sum += i;
 return sum;
 }
 };
```

Now we know how to represent our tasks using the <code class="intf">Callable</code> interface. In the next section we'll explore the <code class="intf">Future</code> interface which will help us manage a task's lifecycle as well as retrieve results from it.

# Callable Interface
In the previous sections we used the <code>Runnable</code> interface as the abstraction for tasks that were submitted to the executor service. The <code>Runnable</code> interface's sole <code>run</code> method doesn't return a value, which is a handicap for tasks that don't want to write results to global or shared datastructures. The interface <code>Callable</code> allows such tasks to return results. Let's see the definition of the interface first.


```
public interface Callable<V> {
 /**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
 V call() throws Exception;
}
```

Note the interface also allows a task to throw an exception. A task goes through the various stages of its life which include the following:
<ul>
<li>created</li>
<li>submitted</li>
<li>started</li>
<li>completed</li>
</ul>

Let's say we want to compute the sum of numbers from 1 to n. Our task should accept an integer n and spit out the sum. Below are two ways to implement our task.


```java
 class SumTask implements Callable<Integer> {

 int n;

 public SumTask(int n) {
 this.n = n;
 }

 public Integer call() throws Exception {

 if (n <= 0)
 return 0;

 int sum = 0;
 for (int i = 1; i <= n; i++) {
 sum += i;
 }
 
 return sum;
 }
 }

```

Or we could take advantage of the anonymous class feature in the Java language to declare our task like so:


```java
 final int n = 10
 Callable<Integer> sumTask = new Callable<Integer>() {
 
 public Integer call() throws Exception {
 int sum = 0;
 for (int i = 1; i <= n; i++)
 sum += i;
 return sum;
 }
 };
```

Now we know how to represent our tasks using the <code>Callable</code> interface. In the next section we'll explore the <code>Future</code> interface which will help us manage a task's lifecycle as well as retrieve results from it.

This lesson discusses the Callable interface.

The Basics

Multithreading in Java

Java Memory Model

Java Thread Basics

Callable Interface

Callable Interface