1. 进程、线程和多线程的概念

进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。多进程操作系统能同时运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的 CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好象是在“同时”运行一样。 线程是比进程更小的执行单位，线程是进程内部单一的一个顺序控制流。也被称为轻量级进程，同一个进程中的所有线程都将共享进程的内存地址空间。因此这些线程都能访问相同的变量并在同一个堆上分配对象。当多个线程访问某个状态变量并且其中一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。 Java中主要的同步机制是synchronized关键字，它提供了一种独占加锁的方式。但“同步”这个术语还包括volatile类型的变量，显示锁（Explicit Lock）以及原子变量。 所谓 多线程 是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在、同时运行，形成多条执行线索。一个进程可能包含了多个同时执行的线程。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程和进程的主要差别体现在以下两个方面： （ 1）、同样作为基本的执行单元，线程是划分得比进程更小的执行单位。 （ 2）、每个进程都有一段专用的内存区域。与此相反，线程却共享内存单元（包括代码和数据），通过共享的内存单元来实现数据交换、实时通信与必要的同步操作。

1.1 多线程和多进程的区别？

最本质的区别就是，每个进程用于一整套的变量，而线程则是共享数据。而且，与进程相比较，线程更“轻量级”，创建、撤销一个线程比启动一个新进程的开销要小很多。

1.2 并发编程的三个特性：原子性，可见性，有序性

在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。我们先看具体看一下这三个概念：

1.2.1 原子性

即一个操作或者多个操作

要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 假定有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B。那么A和B对彼此来说是原子的。 原子操作是指：对于访问同一个状态的所有操作（包括该操作本身）来说，这个操作是一个以原子方式执行的操作。 例如一个经典的银行转账问题： 比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。 试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。 所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。

1.2.2 可见性

是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值

举个简单的例子，例如下面这段代码： 假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。 此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

//线程1执行的代码
int i = 0;
i = 10;
//线程2执行的代码
j = i;

1.2.3 有序性

即程序执行的顺序按照代码的先后顺序执行 比如下面这段代码 代码中定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）

int i = 0;
boolean flag = false;
i = 1;                //语句1
flag = true;          //语句2

2. 线程的基本实例

2.1 未使用多线程的情况

public class Test {
    public static void main(String[] args) {
        new TestThraed().run();
        for (int i = 0; i < 10; i++) {
            System.out.println("main方法在运行"+i);
        }
    }
}
class TestThraed {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("TestThread在运行"+i);
        }
    }
}

上面这段代码是没有使用多线程的情况，程序输出结果是按顺序执行的，也就是先调用TestThread中的run方法，然后再执行main中的for循环

TestThread在运行0
TestThread在运行1
........省略部分..........
TestThread在运行9
main方法在运行0
main方法在运行1
........省略部分..........
main方法在运行9

2.2 使用多线程的情况

public class Test {
    public static void main(String[] args) {
        /**
         * 开启一个新线程并启动它【不要直接调用run方法】
         * 如果直接调用Thread.run()方法，只会执行同一线程【main线程】的任务，而不会启动新线程。
         */
        new TestThraed().start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main方法在运行"+i);
        }
    }
}
class TestThraed extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("TestThread在运行"+i);
        }
    }
}

使用了多线程后，程序的结果是交叉执行的。也就是在main线程中开辟了一个新的线程。由于main本身也占用一条线程，实际上在命令行中运行 java 命令时，就启动了一个 JVM 的进程，默认情况下此进程会产生两个线程：一个是 main()方法线程，另外一个就是垃圾回收（ GC）线程。所以这里是两条线程main线程和new TestThread().start()线程。两个线程同时交替运行着。 结果如下：

main方法在运行0
TestThread在运行0
main方法在运行1
TestThread在运行1
........省略部分..........
main方法在运行8
main方法在运行9
TestThread在运行8
TestThread在运行9

3. 创建线程的两种方式

要想使某个程序是多线程运行的，可以将其变为多线程的程序。多线程程序的run方法中才是该多线程需要执行分解任务的逻辑。任意一个类都是可以变成多线程程序的。 创建线程的方式有如下两种：

1. 实现Runnable接口，该接口中只有一个抽象的run方法 public abstract void run();
2. 继承Thread类，其实Thread类内部也是实现了Runnable接口。只不过内部封装了对线程的一些常用操作。

3.1 实现Runnable接口的方式创建线程

实现Runnable接口，重写run方法

//实现Runnable接口的方式来创建线程
public class Programmer implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("第"+i+"次");
        }
    }
}
//测试多线程
public class TestProgrammer {
    public static void main(String[] args) {
        //1.创建真实角色
        Programmer pro = new Programmer();
        //2.创建代理角色+真实角色的引用
        Thread proxy = new Thread(pro);
        //3.调用start方法，启动线程
        proxy.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("QQ");
        }
    }
}

3.2 继承Thread类方式来创建线程

继承Thread类，重写run方法

//继承Thread类的方式来创建线程
public class Rabbit extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("兔子跑了"+i+"步");
        }
    }
}
//测试多线程
public class TestThread {
    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        rabbit.start();//不要调用run方法
    }
}

注意：启动线程时，不要直接调用Thread或者Runnable接口的run方法，直接调用run方法只会执行同一个线程中的任务。而不会启动新线程。 应该调用Thread.start()方法。这个方法将创建一个执行run方法的新线程。

4. 总结

4.1 线程和进程的区别？

进程是一个程序的动态执行过程，它会在CPU给分配的一块内存中执行一段程序【一个人在一个房间里执行一个程序】 线程只是比进程更小的执行单位，它是进程内部单一的一个顺序控制流。 多线程则是把一个任务进行分解，一个程序在内存执行的时候产生多个线程，多线程共享某块数据。让多个线程来执行该一个程序【多个人在一个房间执行一个程序】 一个进程中可能包括多个线程，一个线程只能属于一个进程。

4.2 线程的创建方式？

继承Thread类或者实现Runnable接口

4.3 继承Thread类还是实现Runnable接口？

推荐实现Runnable接口，避免单继承问题

4.4 线程的启动？

启动一个线程需要调用start()方法，不要直接调用run方法。run方法只会执行同一个线程中的任务而不会去开启新线程。start方法是创建一个执行run方法的新线程。