java多线程回顾1：线程的概念与创建

1、进程与线程的概念

现在几乎所有操作系统都支持多任务，通常一个任务就是一个程序，一个运行中的程序就是一个进程。当一个程序行时，其内部也可能在执行多个任务，进程内每一个任务的执行流，就是一个线程。

所以线程也被称作轻量级进程。

总而言之，线程是进程的组成部分，可以独立、并发的执行任务。

2、线程的创建和启动

Java中有两种方式来创建和启动线程。

2.1继承Thread类创建和启动线程

通过继承Thread类创建并启动多线程的步骤如下：

1、创建Thread的子类，并重写run方法。run方法中就是线程要执行的任务，所以也把run方法称为线程执行体。

2、创建该子类的实例，即线程对象。

3、使用线程对象的start方法启动线程。

线程类代码如下：

 //通过继承Thread类来创建线程类

 public class ThreadOne extends Thread{

     private int i;

     //重写run方法，方法体就是线程要执行的任务

     @Override

     public void run() {

        for (i = 0; i < 20; i++) {

            //继承Thread类时，可以直接调用getName()方法来返回当前线程的名字

            //如果想获取当前线程，直接使用this即可

            System.out.println(getName()+" "+i);

        }

     }

 }

测试代码如下：

 public class TestThreadOne {

     public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {

            //打印主线线程的信息

            System.out.println(Thread.currentThread().getName()+" "+i);

            if (i==3) {

               //创建并启动第一条线程

               new ThreadOne().start();

               //创建并启动第二条线程

               new ThreadOne().start();

            }

        }

     }

 }

部分结果如下：

main 0
main 1
main 2
main 3
Thread-0 0
Thread-1 0
main 4
Thread-1 1
Thread-0 1
Thread-1 2
main 5

从上面的运行结果可以发现，测试类只显式的创建了两条线程，但实际上有三条线程在运行，即主线程、线程0和线程1。其中主线程的线程体是main方法里的内容。

此外，Thread-0和Thread-1两条线程输出的变量i的值是不连续的，而i并非是局部变量，而是实例成员变量，从这一点可以看出，每次创建线程都创建了一个ThreadOne对象。

2.2实现Runnable接口创建线程

实现Runnable接口创建并启动线程的步骤如下：

1、创建Runnable接口的实现类，重写run方法。run方法的内容即是线程要执行的任务。

2、创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象。该Thread对象才是真正的线程类。

线程类代码如下：

 //通过实现Runnable接口创建线程类

 public class ThreadTwo implements Runnable{

     private int i;

     //run方法同样是线程的执行体

     @Override

     public void run() {

        for (i = 0; i < 5; i++) {

            //实现Runnable接口创建线程类时，只能使用Thread.currentThread()来获取当前线程

            System.out.println(Thread.currentThread().getName()+" "+i);

        }

     }

 }

测试代码如下：

 public class TestThreadTwo {

     public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {

            //打印主线线程的信息

            System.out.println(Thread.currentThread().getName()+" "+i);

            if (i==3) {

               ThreadTwo threadTwo = new ThreadTwo();

               //创建并启动第一条线程

               new Thread(threadTwo).start();

               //创建并启动第二条线程

               new Thread(threadTwo).start();

            }

        }

     }

 }

运行结果如下：

 main 0

 main 1

 main 2

 main 3

 Thread-0 0

 Thread-1 0

 main 4

 Thread-1 2

 Thread-0 1

 Thread-0 4

 Thread-1 3

从运行结果可以看出，Thread-0和Thread-1打印的i值是连续的，说明这两条线程是共享一个实例的。这是因为，我们所创建的两个Thread类使用同一个Runnable对象作为target。

在实际开发中，推荐使用实现Runnable接口的方式来创建线程，这样还可以实现或继

2.3有返回值的线程

从JDK1.5开始，java提供Callable接口和Future接口以获得线程的返回值。

Callable类似Runnable的加强版，提供一个call()方法作为线程的执行体。与Runnable的run()方法相比，call()方法更强大：

• call()方法可以有返回值
• call()可以声明抛出异常

不过Callable对象并不能直接作为Thread的target，必须使用Future对象包装一下。具体使用步骤如下：

• 创建Callable的实现类，并实现call方法，注意有泛型限制。
• 使用FutureTask包装Callable对象。
• 把FutureTask作为target传入Thread，创建启动线程。
• 调用FutureTask对象的方法获取返回值。

线程代码：

 public class CallableOne implements Callable<Integer>{

     @Override

     public Integer call() throws Exception {

        int i = 0;

        for(i=0;i<10;i++){

            System.out.println(Thread.currentThread().getName()+" "+i);

        }

        //线程返回值,模拟返回前阻塞主线程

        Thread.sleep(5000);

        return i;

     }

 }

测试代码：

 public class TestCallable {

     public static void main(String[] args) {

        //创建Callable对象

        CallableOne callableOne = new CallableOne();

        //使用FutureTask包装Callable对象

        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableOne);

        for(int i=0;i<100;i++){

            System.out.println(Thread.currentThread().getName()+" "+i);

            //i等于3时启动子线程，此时可见主线程与子线程交替执行

            if (i==3) {

               //FutureTask是Runnable的子类，可传入Thread当作target

               new Thread(futureTask).start();

            }

            //i等于80的时候来获取子线程的返回值，此时主线程会阻塞，直到返回了结果

            if (i==80) {

               try {

                   System.out.println("线程的返回值："+futureTask.get());

               } catch (Exception e) {

                   e.printStackTrace();

               }

            }

        }

     }

 }

以上代码中，在i等于3时启动子线程，此时可见主线程与子线程交替执行。在i等于80的时候来获取子线程的返回值，此时主线程会阻塞，直到返回结果。