Java中的多线程

在Java中一个很重要的基础就是线程，而每次提到线程大家必想到的是进程，所以在总结Java多线程之前我们先对进程和线程进行一下区分：

进程：一个计算机程序的运行实例，每个进程有独立的代码和数据空间（进程上下文），而一个进程中可以有多个线程；

线程：是进程中运行的一个实体，同一类线程共享代码和数据空间，每个下城有独立的运行栈；

但是它们都有五个运行的阶段：创建-->就绪-->运行-->阻塞-->终止；

在Java中多线程的启动主要有三种方式：继承Thread类重写该类的run()方法，实现Runnable接口；使用Callable和Future接口创建线程；下面就一一来看，这三种不同的启动方式的代码实现：

➷   扩展Thread类重写该类的run()方法

/** * 测试扩展Thread类实现的多线程程序* */ publicclass TestThread extends Thread{     public TestThread(String name) {        super(name);    }     publicvoid run() {        for(int i = 0;i<5;i++){            for(long k= 0; k <100000000;k++);            System.out.println(this.getName()+" :"+i);        }     }     publicstaticvoid main(String[] args) {        Thread t1 = new TestThread("阿三");        Thread t2 = new TestThread("李四");        t1.start();         t2.start();     } }

执行结果如下：

阿三 :0李四 :0 阿三 :1 李四 :1 阿三 :2 李四 :2 阿三 :3 阿三 :4 李四 :3 李四 :4 Process finished with exit code 0

➷  实现Runnable接口

<span style="font-size:18px;">/** * 实现Runnable接口的类* */ publicclass DoSomethingimplements Runnable {    private String name;    public DoSomething(String name) {        this.name = name;    }     publicvoid run() {        for (int i = 0; i < 5; i++) {            for (long k = 0; k < 100000000; k++) ;            System.out.println(name + ": " + i);        }     } }</span>

<span style="font-size:18px;">/** * 测试Runnable类实现的多线程程序* */ publicclass TestRunnable {    publicstaticvoid main(String[] args) {        DoSomething ds1 = new DoSomething("阿三");        DoSomething ds2 = new DoSomething("李四");        Thread t1 = new Thread(ds1);        Thread t2 = new Thread(ds2);        t1.start();         t2.start();     } }</span>

    执行的结果为：

李四: 0阿三: 0 李四: 1 阿三: 1 李四: 2 李四: 3 阿三: 2 李四: 4 阿三: 3 阿三: 4 Process finished with exit code 0

➷ 使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现call方法；使用Future Task类来包装Callable实现类的对象，且以此FutureTask 对象作为Thread对象的target来创建线程。

<span style="font-size:18px;">public class ThreadTest {    public static void main(String[] args) {        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象        for (int i = 0; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + " " + i);            if (i == 30) {                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程                thread.start();                      //线程进入到就绪状态            }        }        System.out.println("主线程for循环执行完毕..");                try {            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果            System.out.println("sum = " + sum);        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }    }}class MyCallable implements Callable<Integer> {    private int i = 0;    // 与run()方法不同的是，call()方法具有返回值    @Override    public Integer call() {        int sum = 0;        for (; i < 100; i++) {            System.out.println(Thread.currentThread().getName() + " " + i);            sum += i;        }        return sum;    }}</span>

这时我们可以发现，在实现Callable接口的不再是run()方法了，而是call方法，这个call方法作为线程的执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target，下面是Future Task类的定义：

<span style="font-size:18px;"> public class FutureTask<V> implements RunnableFuture<V> {          //....      }  public interface RunnableFuture<V> extends Runnable, Future<V> {          void run();      }</span>

从上面的代码我们可以发现，Future Task 类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。

上面主要讲解了三种常见的线程创建方式，但是相比较而言，Runnable接口实现要比继承Thread类具有很大的优势，如：

1.Runnable适合多个相同的程序代码的线程去处理同一个资源

2.可以避免Java中的单继承的限制

3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

         至于线程的启动，都是调用start()方法，需要特别注意的：我们不能对同一线程对象两次调用start()方法；
 以上就是关于多线程的基本介绍和三种创建方式，希望能帮助大家更好的去理解Java中的多线程，更高效地使用线程开发程序；