1、进程和线程的概念
1）进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
2）线程（Thread），有时被称为轻量级进程（Lightweight Process,LWP），是程序执行流的最小单元。线程是程序中一个单一的顺序控制流程，代表不同的执行路径。是进程内一个相对独立、可调度的执行单元，是系统独立调度和分派CPU的基本单位，也指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程.
3）关系：一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.
相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
4）区别
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
- 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
- 线程的划分尺度小于进程，使得多线程程序的并发性高。
- 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
- 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
- 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
2、多线程
多线程就是指一个进程中同时有多个执行路径（线程）正在执行，完成不同的工作，比如卡密充值，当你提交卡密之后，都会先提示提交，等待充值结果，这种都是把卡密入库，然后异步开启多个线程处理校验和充值操作。
注意：多线程是异步的，但这不代表多线程真的是几个线程是在同时进行（在同一个时间点上，CPU只能支持一个线程在执行），实际上是CPU不断地在各个线程之间来回的切换（因为CPU切换的速度非常的快，所以给我们在同时运行的错觉）。
- 为什么要是用多线程？
1.在一个程序中，有很多的操作是非常耗时的，如数据库读写操作，IO操作等，如果使用单线程，那么程序就必须等待这些操作执行完成之后才能执行其他操作。使用多线程，可以在将耗时任务放在后台继续执行的同时，同时执行其他操作。
2.可以充分利用CPU的资源，提高程序的效率。
- 线程与高并发
高并发：高并发指的是是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在这段时间内执行大量操作，例如对资源的请求，数据库的操作等。如果高并发处理不好，不仅仅降低了用户的体验度（请求响应时间过长），同时可能导致系统宕机，严重的甚至导致OOM（out of memory）异常，系统停止工作等。如果要想系统能够适应高并发状态，则需要从各个方面进行系统优化，包括，硬件、网络、系统架构、开发语言的选取、数据结构的运用、算法优化、数据库优化……。
多线程只是在同/异步角度上解决高并发问题的其中的一个方法手段，是在同一时刻利用计算机闲置资源的一种方式。
多线程在高并发问题中的作用就是充分利用计算机资源，使计算机的资源在每一时刻都能达到最大的利用率，不至于浪费计算机资源使其闲置。
3、主线程
在JAVA里面，JAVA的线程是通过java.lang.Thread类来实现的，每一个Thread对象代表一个新的线程。实现多线程编程。
-
程序开发好了之后，如何运行？
1）程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了。
2）主线程作为程序的入口，也就是main方法（java中main方法是特殊的存在，有main方法，虚拟机才能调用并执行）。
3）有了主线程，才能通过主线程来产生其它的子线程，并且线程最后都要执行完成，并释放。
main方法，里面调用别的方法，别的方法又调用其它方法，这个时候必须等调用的所有的方法执行结束，返回main方法，这个时候才能继续向下执行，这种就是简单的单线程。
4、线程的创建和启动
使用线程的步骤：定义线程->创建线程对象->启动线程->终止线程
创建线程三种方式：
1、继承java.lang.Thread类
2、实现java.lang.Runable接口
3、实现java.util.concurrent.Callable接口
使用方式1：
1）自定义线程类MyThread继承Thread类
2）重写run()方法，编写线程执行体，自动调用，不能手动调用，否则是普通方法
3）创建线程对象，调用start()方法启动线程，一个线程只能调用一次start方法,多次启动会报错：java.lang.IllegalThreadStateException 线程状态非法异常
- 示例
public class MyThread extends Thread {
public void run() {
System.out.println("Mythread is running...");
for (int i = 0; i < 10; i++) {
System.out.println("当前线程名称：" + Thread.currentThread().getName() + "----" + i);
}
}
}
public static void main(String[] args) {
// 创建自定义线程对象
MyThread myThread1 = new MyThread();
// 启动一个线程，使用的是start方法，自动调用线程的run方法
myThread1.start();
// 直接调用run方法，就是普通的方法调用，是顺序执行的
// myThread.run();
// myThread.start(); 这个时候异常，不会重新再启动线程
}
注意：
1）一旦线程启动后 start 方法就会立即返回，而不会等待到 run 方法执行完毕才返回
2）多个线程交替执行，不是真正的“并行”，而是我们说的并发（通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时），线程每次执行时长由分配的CPU时间片长度决定
3）直接调用run方法，这个变成普通的方法调用，执行调用的线程是main方法这个主线程，而且调用执行也是按照顺序执行的，即单线程。而start方法是单独启动一个子线程，自动调用run方法，及多条执行路径，主线程和子线程并行交替（并发）执行。
使用方式二：
1）定义自定义类MyRunnable实现Runnable接口
2）实现run()方法，编写线程执行体
3）创建线程对象，同样调用start()方法启动线程
- 示例
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("MyRunnable is running...");
for (int i = 0; i < 10; i++) {
System.out.println("当前线程名称：" + Thread.currentThread().getName() + "----" + i);
}
}
}
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
// 以形参的方式传递给Thread类，构造线程实例
Thread thread1 = new Thread(myRunnable);
thread1.start();
}
两种方式对比：
实现Runnable接口相对于继承Thread类来说，显著的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。 多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数 实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
使用方式3
1）定义自定义类MyCallable实现Callable接口
2）实现call()方法，编写线程执行体
3）创建线程对象，同样调用start()方法启动线程
- 示例
/**
* 实现线程的方式3：实现Callable接口，可以获取返回值
*/
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System.out.println("开始运算：");
int sum = 0;
for (int i = 1; i < 10; i++) {
sum += i;
}
return sum;
}
public static void main(String[] args) {
MyCallable myCallable = new MyCallable();
// 执行，必须借助实现类：FutureTask，接收返回结果
FutureTask<Integer> result = new FutureTask<Integer>(myCallable);
System.out.println("执行开始：");
// 创建线程并启动
new Thread(result).start();
// 获取结果
Integer sumResult;
try {
sumResult = result.get();
System.out.println("10以内数字之和：" + sumResult);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("执行结束！！！");
}
}
- 小结
1、实现Callable接口和实现Runnable接口都可以实现多线程，但是实现Runnable接口的run（）方法是没有返回值的，而Callable接口可以返回指定类型的值。
2、Callable接口在java.util.consurrent包中，JDK 1.5之后提出。
3、Callable接口本身并不具备执行能力，因此Java提供了一个FutureTask类来使用Callable接口定义的具有返回值的任务。
4、Callable的对象必须先封装到FutureTask中，然后通过FutureTask传给Thread类，这样才能启动多线程。
5、FutureTask的get（）方法可以获取到Callable接口实现任务的返回值。
6、call()方法可抛出异常，而run()方法是不能抛出异常的。
