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的时候来获取子线程的返回值，此时主线程会阻塞，直到返回结果。