Java创建线程的三种方式

1.继承Thread类，重写run方法。

缺点：java是单继承，继承了Thread类，不可继承其他类，不方便扩展。
开发中：少用。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            while (true) {
                System.out.println("实现Runnable接口的方式" + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            new RuntimeException("错误信息为：" + e.getMessage());
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

2.实现Runnable接口，实现run方法。

优点：该类实现了Runnable接口，同时也可以继承其他类，可扩展。
开发：常用。

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            Thread.sleep(1000);
            while(true){
                System.out.println("继承Thread类方式"+Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            new RuntimeException("错误信息为："+e.getMessage());
        }
    }

    public static void main(String[] args) {
        new MyThread().start();
    }
}

3.实现Callable接口，重写call方法。

优点：可以获取返回值，可扩展。
开发：目前遇到过Oracle底层代码中使用过此方法。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        int count = 0;
        for(int i = 0;i < 10; i++){
            count++;
            System.out.println("继承Thread类方式"+Thread.currentThread().getName());
        }
        return "运行了"+count+"次，并且有返回值";
    }


    public static void main(String[] args) {
        try {



        }  catch (Exception e) {
            new RuntimeException("错误信息为："+e.getMessage());
        }
    }
}

Callable和Runnable区别

(1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如果线程没有执行完，Future.get()方法可能会阻塞当前线程的执行；如果线程出现异常，Future.get()会throws InterruptedException或者ExecutionException；如果线程已经取消，会跑出CancellationException。取消由cancel 方法来执行。isDone确定任务是正常完成还是被取消了。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        int count = 0;
        for(int i = 0;i < 10; i++){
            count++;
            System.out.println("继承Thread类方式"+Thread.currentThread().getName());
        }
        return "运行了"+count+"次，并且有返回值";
    }


    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); //3的意思是the number of threads in the pool
        MyCallable myCallable = new MyCallable();

        try {
        //启动线程方式1
        Future<Object> submit = executor.submit(myCallable);
        Object object = submit.get();
        System.out.println(object);
        executor.shutdown();//关闭线程

        //启动线程方式2
        Object call = myCallable.call();//启动线程
        System.out.println(call); //输出 ：运行了10次，并且有返回值
        }  catch (Exception e) {
            new RuntimeException("错误信息为："+e.getMessage());
        }
    }
}

• ExecutorService中的方法
  

• Future源码，方法顾名思义

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);


    boolean isCancelled();


    boolean isDone();


    V get() throws InterruptedException, ExecutionException;


    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future模式并发使用：
请看文章http://blog.csdn.net/z3881006/article/details/54578066