一、线程与进程

操作系统中可以支持多个程序同时运行，每个程序就代表了一个进程，各个程序即进程间相互独立工作，而每个程序中可能包含多个顺序执行流，每个执行流就代表了一个线程，各个线程共享进程中的资源。

1.什么是进程

进程是系统进行资源调度与分配的最小单位，一般而言，进程具有三个特点：

独立性：每个进程都有自己独立的私有资源，不与其他进程共享，也就是说，其他进程不可以直接访问其他进程的地址空间。
动态性：进程具有自己的生命周期和状态转变。
并发性：并发是指在同一时刻只能有一条指令执行，但多个进程可以被快速轮换执行，由于处理速度非常快，感觉上多个进程在同时进行。

2.什么是线程

线程也被成为轻量级进程，当进程中需要并发执行多个任务时，就需要使用线程的概念，线程是进程的执行单元，它们可以共享进程中的资源。

3.进程与线程的区别

进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元。
同一个进程中可以包含多个线程，一个进程中至少包含一个主线程。
同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
同一个进程中的线程可以并发执行。
线程间的通信比进程间通信要方便的多，但是线程之间需要处理好同步与互斥的关系。

二、线程的创建与启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例，Java中创建多线程有三种方法：

继承Thread类重写run方法
实现Runnable接口重写run方法
使用Callable和Future创建线程

1.继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

代码如下所示：

public class ThreadTest extends Thread{
    int i = 0;
    @Override
    public void run(){
        for(;i<50;i++){
            System.out.println(getName() + " " +i);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest thread1 = new ThreadTest();
        ThreadTest thread2 = new ThreadTest();
        for(int i=0; i<50;i++){
            System.out.println(Thread.currentThread().getName()+"  : "+i);  
            if(i==10)  
            {
                thread1.start();
                thread2.start();
            }
        }
    }

}

运行结果可能如下所示：

main  : 15
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
main  : 16
Thread-1 6
main  : 17
Thread-0 0
Thread-1 7
Thread-0 1
main  : 18
Thread-0 2
Thread-1 8
Thread-0 3
main  : 19
main  : 20
Thread-0 4

由测试结果可知，main进程执行至i=10时，开始新建两个新线程，两个新线程从i=0开始分别执行，Thread-0和Thread-1中的i值是不连续的，证明两个线程中的i值不共享，因为两个新线程是ThreadTest创建的两个实例，所以i值

2.实现Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。

代码如下所示：


public class RunnableTest implements Runnable{
    int i = 0;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " " +i);
        }

    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        RunnableTest runnable = new RunnableTest();
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
            if(i==20)  
            {  
                new Thread(runnable,"线程1").start();  
                new Thread(runnable,"线程2").start();  
            }  
        }  
    }

}

3.使用Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

三、三种创建方式的对比

采用实现Runnable、Callable接口的方式创见多线程时，优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。