线程相关类-Callable Runnable Thread

1创建线程的办法

1. 直接继承Thread

2. 实现Runnable接口
   这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。
   而自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。

3. Callable

2.Thread和Runnable区别

1. Thread是类，需要继承，而只能继承一个父类，有局限性。
2. Thread可直接用start()方法启动线程，而Runnable没有start()方法，需要使用newThread(object).start()；
3. Runnable就可以实现资源共享，而通过Thread类实现，各自线程的资源是独立的，不方便共享。

public static void main(String[] args) {  
        // TODO Auto-generated method stub  

            new MyThread().start();  
            new MyThread().start();  

    }  


class MyThread extends Thread{    
    private int ticket = 5;    
    public void run(){    
         while(true){  
             System.out.println("Thread ticket = " + ticket--);    
             if(ticket < 0){    
                break;  
             }    
         }    
    }    
} 
//输出结果
Thread ticket = 5  
Thread ticket = 5  
Thread ticket = 4  
Thread ticket = 4  
Thread ticket = 3  
Thread ticket = 2  
Thread ticket = 3  
Thread ticket = 1  
Thread ticket = 2  
Thread ticket = 0  
Thread ticket = 1  
Thread ticket = 0  

public static void main(String[] args) {  
        // TODO Auto-generated method stub  

            MyThread2 m= new MyThread();
            new Thread(m).start();
            new Thread(m).start();

    }

class MyThread2 implements Runnable{    
    private int ticket = 5;    
    public void run(){    
         while(true){  
             System.out.println("Runnable ticket = " + ticket--);    
             if(ticket < 0){    
                break;  
             }    
         }   
    }    
} 
//输出结果：资源的共享
Runnable ticket = 5  
Runnable ticket = 4  
Runnable ticket = 3  
Runnable ticket = 2  
Runnable ticket = 1  
Runnable ticket = 0  

3.Callable和Runnable

1.接口的定义

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

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

2.Callable和Runnable的异同
Callable的call()方法类似于Runnable接口中run()方法，都定义任务要完成的工作，实现这两个接口时要分别重写这两个方法，主要的不同之处是call()方法是有返回值的（其实还有一些区别，例如call方法可以抛出异常，run方法不可以），运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

3.Callable类型的任务可以有两种执行方式
我们先定义一个Callable任务MyCallableTask:

class MyCallableTask implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

①借助FutureTask执行
FutureTask类同时实现了两个接口，Future和Runnable接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
借助FutureTask执行的大体流程是：

Callable<Integer> mycallabletask = new MyCallableTask();  
FutureTask<Integer> futuretask= new FutureTask<Integer>(mycallabletask);  
new Thread(futuretask).start();

通过futuretask可以得到MyCallableTask的call()的运行结果：
futuretask.get()

②借助线程池来运行
线程池中执行Callable任务的原型例如：

public interface ExecutorService extends Executor {

  //提交一个Callable任务，返回值为一个Future类型
  <T> Future<T> submit(Callable<T> task);

  //other methods...
  }

借助线程池来运行Callable任务的一般流程为：

  ExecutorService exec = Executors.newCachedThreadPool();
  Future<Integer> future = exec.submit(new MyCallableTask());

通过future可以得到MyCallableTask的call()的运行结果：
future.get();

4.相关例子
a.Callable任务借助FutureTask运行：

public class CallableAndFutureTask {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };
        FutureTask<Integer> future = new FutureTask<Integer>(callable);
        new Thread(future).start();
        try {
            Thread.sleep(5000);
            System.out.println(**future.get()**);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

b.Callable任务和线程池一起使用，然后返回值是Future:

public class CallableAndFuture {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<Integer> future = threadPool.submit(new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        });
        try {
            Thread.sleep(5000);// 可能做一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

c.当执行多个Callable任务，有多个返回值时，我们可以创建一个Future的集合

class MyCallableTask implements Callable<String> {
    private int id;  
    public OneTask(int id){  
        this.id = id;  
    }  
    @Override  
    public String call() throws Exception {  
        for(int i = 0;i<5;i++){
            System.out.println("Thread"+ id);  
            Thread.sleep(1000); 
        }  
        return "Result of callable: "+id;  
    }   
}
public class Test {   

    public static void main(String[] args) {  
        //Callable<String> mycallabletask = new MyCallableTask(1);  
        ExecutorService exec = Executors.newCachedThreadPool();    
        ArrayList<Future<String>> results = new ArrayList<Future<String>>();      

        for (int i = 0; i < 5; i++) {    
            results.add(exec.submit(new MyCallableTask(i)));    
        }    

        for (Future<String> fs : results) {    
            if (fs.isDone()) {    
                try {  
                    System.out.println(fs.get());   
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            } else {    
                System.out.println("MyCallableTask任务未完成！");    
            }    
        }    
        exec.shutdown();  
    }  
}