可以取得返回值的线程

编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable.

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

1、通过实现Runnable接口来创建Thread线程：

  步骤1：创建实现Runnable接口的类：

         
class SomeRunnable implements Runnable
{
    public void run()
    {
      //do something here
    }
}

步骤2：创建一个类对象：

       Runnable oneRunnable = new SomeRunnable();

步骤3：由Runnable创建一个Thread对象：

       Thread oneThread = new Thread(oneRunnable);

步骤4：启动线程：

        oneThread.start();

至此，一个线程就创建完成了。

注释：线程的执行流程很简单，当执行代码oneThread.start();时，就会执行oneRunnable对象中的void run();方法，

该方法执行完成后，线程就消亡了。

2、与方法1类似，通过实现Callable接口来创建Thread线程：其中，Callable接口（也只有一个方法）定义如下：

public interface Callable<V>   
{   
    V call() throws Exception;   
} 
步骤1：创建实现Callable接口的类SomeCallable<Integer>（略）；

步骤2：创建一个类对象：

      Callable<Integer> oneCallable = new SomeCallable<Integer>();

步骤3：由Callable<Integer>创建一个FutureTask<Integer>对象：

      FutureTask<Integer> oneTask = new FutureTask<Integer>(oneCallable);

      注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。
步骤4：由FutureTask<Integer>创建一个Thread对象：

       Thread oneThread = new Thread(oneTask);

步骤5：启动线程：

       oneThread.start();

至此，一个线程就创建完成了。

3、通过继承Thread类来创建一个线程：

步骤1：定义一个继承Thread类的子类：

       

class SomeThead extends Thraad
{
    public void run()
    {
     //do something here
    }
}

步骤2：构造子类的一个对象：

      SomeThread oneThread = new SomeThread();

步骤3：启动线程：

      oneThread.start();

至此，一个线程就创建完成了。

       注释：这种创建线程的方法不够好，主要是因为其涉及运行机制问题，影响程序性能。

4、通过线程池来创建线程：

步骤1：创建线程池：

      ExecutorService pool = Executors.newCachedThreadPool();

步骤2：通过Runnable对象或Callable对象将任务提交给ExecutorService对象：

      Future<Integer> submit(Callable<Integer> task);

      注释：Future是一个接口，它的定义如下：

               
public interface Future<T>
{
    V get() throws ...;
    V get(long timeout, TimeUnit unit) throws ...;
    void cancle(boolean mayInterrupt);
    boolean isCancelled();
    boolean isDone();
}

      至此，一个线程就创建完成了。

      注释：线程池需调用shutdown();方法来关闭线程。

5、通过事件分配线程直接使用程序中的原有线程：

使用方法：
直接调用EventQueue类的静态方法invokeLater()：

      EventQueue.invokeLater(oneRunnable);

      注释：调用EventQueue.invokeLater(oneRunnable);会直接执行oneRunnable对象中的run()方法

Runnbale封装一个异步运行的任务，可以把它想象成一个没有任何参数和返回值的异步方法。Callable和Runnable相似，但是它有返回值。Callable接口是参数化的类型，只有一个方法call

public interface Callable<V> {

    V call() throws Exception;

}

类型参数就是返回值的类型，例如：Callable<String>表示最终返回一个String的异步操作（计算）

Runnbale封装一个异步运行的任务，可以把它想象成一个没有任何参数和返回值的异步方法。Callable和Runnable相似，但是它有返回值。Callable接口是参数化的类型，只有一个方法call（）

public interface Callable<V> {

    V call() throws Exception;

}

类型参数就是返回值的类型，例如：Callable<String>表示最终返回一个String的异步操作（计算）

 
 
//求素数 
class PrimeCallable implements Callable<int[]> { 
    private int max; 
     
    public PrimeCallable(int max) { 
        this.max = max; 
    } 
     
    @Override 
    public int[] call() throws Exception { 
        List<Integer> result = new ArrayList<Integer>(); 
        for(int i = 2; i <= max; i++) { 
            System.out.println("System is checking data " + i); 
            if(isPrime(i)) { 
                result.add(i); 
            } 
        } 
         
        Integer[] iters = result.toArray(new Integer[]{}); 
        int[] array = new int[iters.length]; 
        int i = 0; 
        for(Integer iter : iters) { 
            array[i++] = iter; 
        } 
        return array; 
    } 
     
    private boolean isPrime(int data) { 
        try { 
            Thread.sleep(5); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        for(int i = 2; i < ((int)Math.sqrt(data)+1); i++) { 
            if(data % i == 0)  
                return false; 
        } 
        return true; 
    } 
} 

 
 
Callable<int[]> primeCallable = new PrimeCallable(1000); 
        FutureTask<int[]> ftask = new FutureTask<int[]>(primeCallable); 
         
        Thread t = new Thread(ftask); 
        t.start(); 
         
        int[] result = null; 
        System.out.println("Waiting for result....."); 
        try { 
            result = ftask.get(); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } catch (ExecutionException e) { 
            e.printStackTrace(); 
        } 
         
        for(int i = 0; result != null && i < result.length; i++) { 
            if(i != 0 && i % 10 == 0) { 
                System.out.println(); 
            } 
            System.out.print(String.format("%1$-5s", result[i])); 
        } 

 
 
执行结果： 
Waiting for result..... 
System is checking data 2 
System is checking data 3 
System is checking data 4 
System is checking data 5 
System is checking data 6 
System is checking data 7 
.................................. 
System is checking data 999 
System is checking data 1000 
2    3    5    7    11   13   17   19   23   29    
31   37   41   43   47   53   59   61   67   71    
73   79   83   89   97   101  103  107  109  113   
127  131  137  139  149  151  157  163  167  173   
179  181  191  193  197  199  211  223  227  229   
233  239  241  251  257  263  269  271  277  281   
283  293  307  311  313  317  331  337  347  349   
353  359  367  373  379  383  389  397  401  409   
419  421  431  433  439  443  449  457  461  463   
467  479  487  491  499  503  509  521  523  541   
547  557  563  569  571  577  587  593  599  601   
607  613  617  619  631  641  643  647  653  659   
661  673  677  683  691  701  709  719  727  733   
739  743  751  757  761  769  773  787  797  809   
811  821  823  827  829  839  853  857  859  863   
877  881  883  887  907  911  919  929  937  941   
947  953  967  971  977  983  991  997