1、进程与线程的概念
现在几乎所有操作系统都支持多任务，通常一个任务就是一个程序，一个运行中的程序就是一个进程。当一个程序行时，其内部也可能在执行多个任务，进程内每一个任务的执行流，就是一个线程。
所以线程也被称作轻量级进程。
总而言之，线程是进程的组成部分，可以独立、并发的执行任务。
2、线程的创建和启动
Java中有两种方式来创建和启动线程。
2.1继承Thread类创建和启动线程
通过继承Thread类创建并启动多线程的步骤如下：
1、创建Thread的子类，并重写run方法。run方法中就是线程要执行的任务，所以也把run方法称为线程执行体。
2、创建该子类的实例，即线程对象。
3、使用线程对象的start方法启动线程。
线程类代码如下：
1 //通过继承Thread类来创建线程类 2 3 public class ThreadOne extends Thread{ 4 5 private int i; 6 7 8 9 //重写run方法，方法体就是线程要执行的任务 10 11 @Override 12 13 public void run() { 14 15 for (i = 0; i < 20; i++) { 16 17 //继承Thread类时，可以直接调用getName()方法来返回当前线程的名字 18 19 //如果想获取当前线程，直接使用this即可 20 21 System.out.println(getName()+" "+i); 22 23 } 24 25 } 26 27 }
测试代码如下：
1 public class TestThreadOne { 2 3 public static void main(String[] args) { 4 5 for (int i = 0; i < 10; i++) { 6 7 //打印主线线程的信息 8 9 System.out.println(Thread.currentThread().getName()+" "+i); 10 11 if (i==3) { 12 13 //创建并启动第一条线程 14 15 new ThreadOne().start(); 16 17 //创建并启动第二条线程 18 19 new ThreadOne().start(); 20 21 } 22 23 } 24 25 } 26 27 }
部分结果如下：
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对象才是真正的线程类。
线程类代码如下：
1 //通过实现Runnable接口创建线程类 2 3 public class ThreadTwo implements Runnable{ 4 5 private int i; 6 7 8 9 //run方法同样是线程的执行体 10 11 @Override 12 13 public void run() { 14 15 for (i = 0; i < 5; i++) { 16 17 //实现Runnable接口创建线程类时，只能使用Thread.currentThread()来获取当前线程 18 19 System.out.println(Thread.currentThread().getName()+" "+i); 20 21 } 22 23 } 24 25 }
测试代码如下：
1 public class TestThreadTwo { 2 3 public static void main(String[] args) { 4 5 for (int i = 0; i < 5; i++) { 6 7 //打印主线线程的信息 8 9 System.out.println(Thread.currentThread().getName()+" "+i); 10 11 if (i==3) { 12 13 ThreadTwo threadTwo = new ThreadTwo(); 14 15 //创建并启动第一条线程 16 17 new Thread(threadTwo).start(); 18 19 //创建并启动第二条线程 20 21 new Thread(threadTwo).start(); 22 23 } 24 25 } 26 27 } 28 29 }
运行结果如下：
1 main 0 2 3 main 1 4 5 main 2 6 7 main 3 8 9 Thread-0 0 10 11 Thread-1 0 12 13 main 4 14 15 Thread-1 2 16 17 Thread-0 1 18 19 Thread-0 4 20 21 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对象的方法获取返回值。
线程代码：
1 public class CallableOne implements Callable<Integer>{ 2 3 @Override 4 5 public Integer call() throws Exception { 6 7 int i = 0; 8 9 for(i=0;i<10;i++){ 10 11 System.out.println(Thread.currentThread().getName()+" "+i); 12 13 } 14 15 //线程返回值,模拟返回前阻塞主线程 16 17 Thread.sleep(5000); 18 19 return i; 20 21 } 22 23 }
测试代码：
1 public class TestCallable { 2 3 public static void main(String[] args) { 4 5 //创建Callable对象 6 7 CallableOne callableOne = new CallableOne(); 8 9 //使用FutureTask包装Callable对象 10 11 FutureTask<Integer> futureTask = new FutureTask<Integer>(callableOne); 12 13 for(int i=0;i<100;i++){ 14 15 System.out.println(Thread.currentThread().getName()+" "+i); 16 17 //i等于3时启动子线程，此时可见主线程与子线程交替执行 18 19 if (i==3) { 20 21 //FutureTask是Runnable的子类，可传入Thread当作target 22 23 new Thread(futureTask).start(); 24 25 } 26 27 //i等于80的时候来获取子线程的返回值，此时主线程会阻塞，直到返回了结果 28 29 if (i==80) { 30 31 try { 32 33 System.out.println("线程的返回值："+futureTask.get()); 34 35 } catch (Exception e) { 36 37 e.printStackTrace(); 38 39 } 40 41 } 42 43 } 44 45 } 46 47 }
以上代码中，在i等于3时启动子线程，此时可见主线程与子线程交替执行。在i等于80的时候来获取子线程的返回值，此时主线程会阻塞，直到返回结果。