并发之创建线程

多线程编程可是神通：三头六背，实际代码中如果有性能方面的要求，可以考虑下用下：

这里只是举简单例子，实际应用还有许多注意项的。

Java可以用三种方式来创建线程，如下所示：

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

下面让我们分别来看看这三种创建线程的方法。

 1）继承Thread类创建线程

package Test.ThreadLocal;
public class ThreadDemo extends Thread {
    @Override
    public void run() {
        // 重写run方法
        System.out.println("Hello,Word!");
    }
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo t = new ThreadDemo();
        t.start();//创建并启动线程
        t.join();
    }
}

1、必须继承Thread类

2、重写执行体，run()方法

3、以start()方法启动线程

 

java8 真的能让人上瘾：

new Thread(() -> System.out.println("Hello world !")).start();

2）实现Runnable接口创建线程

package Test.ThreadLocal;
public class RunnableDemo implements Runnable{
    
    @Override
    public void run() {
        // 重写run方法
        System.out.println("Hello,Word!");
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        RunnableDemo r = new RunnableDemo();
        new Thread(r).start();
    }
}

1、必须实现Runnable

2、重写执行体，run()方法

3、以new Thread().start()方法启动线程

java8 

 Runnable race2 = () -> {
            System.out.println("race2-Hello world !");
        };
new Thread(race2).start();

3）使用Callable和Future创建线程

package Test.ThreadLocal;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        return sum;
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        CallableDemo c = new CallableDemo();
        //执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
        FutureTask<Integer> result = new FutureTask<Integer>(c);
        new Thread(result).start();
        try {
            Integer sum = result.get();//
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

（1）Callable规定的方法是call()，而Runnable规定的方法是run(). 

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。  

（3）call()方法可抛出异常，异常绑定在future.get()中，而run()方法是不能抛出异常的。 

（4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 

它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。 

通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。 

Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。