1、进程与线程
进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。正在运行的程序实例，进程是线程的容器，即一个进程中可以开启多个线程。比如打开浏览器、word等操作，都会创建进程。
线程：是进程内部一个独立执行单元；一个进程可以同时并发运行多个线程，类似于工厂里的工人，工人把工厂按照一定的规则继续运行下去。
一个程序由一个或多个进程组成，一个进程由一个或多个线程组成。
进程与线程的区别？
1、地址空间：进程之间是独立的地址空间，但同一进程的线程共享本进程的地址空间。
2、资源占用：同一进程内的线程共享本进程的资源如内存（堆，方法区）、I/O、cpu等，但是进程之间的资源是独立的。
3、健壮性：因为同一进程的所以线程共享此线程的资源，因此当一个线程发生崩溃时，此进程也会发生崩溃。 但是各个进程之间的资源是独立的，因此当一个进程崩溃时，不会影响其他进程。因此进程比线程健壮。
4、执行过程：每个独立的进程程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
进程与线程的选择取决条件？
进程是资源分配的基本单位，线程是程序执行的最小单位
1、在程序执行过程中，如果需要频繁创建和销毁的使用线程。因为进程的创建和销毁开销很大（需要不停的分配资源），但是线程频繁的调用只是改变CPU的执行，开销大小。
2、如果需要程序更加的稳定安全时，可以选择进程。如果追求速度，就选择线程。
2、并发与并行
想要学习多线程，必须先理解什么是并发与并行
并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行.
并发：当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。
① 程序与计算不再一一对应，一个程序副本可以有多个计算
② 并发程序之间有相互制约关系，直接制约体现为一个程序需要另一个程序的计算结果，间接制约体现为多个程序竞争某一资源，如处理机、缓冲区等。
③ 并发程序在执行中是走走停停，断续推进的。
并发连接数
防火墙，所能处理的最大会话数量，就是“并发连接数”。
3、线程创建
Java中线程有4种创建方式
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口
- 线程池
3.1 继承Thread类
创建和自定义线程类
/**
* @Auther: mengyang
* @Date: 2020/1/19 0020 21:20
* @Description: 继承Thread类实现多线程
* @statement:
*/
public class MyThread extends Thread {
public void run(){
for (int i=0;i<10;i++){
System.out.println("myThread线程正在执行："+i);
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
for (int i = 0;i<10;i++) {
System.out.println("主进程正在执行："+i);
}
}
}
执行效果如下：
3.2 实现Runnable接口
创建自定义类实现Runnable接口
package com.mall.thread;
/**
* @Auther: mengyang
* @Date: 2020/1/19 0020 21:20
* @Description: 实现Runnable接口实现多线程
* @statement:
*/
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("myRunnable线程正在执行："+i);
}
}
//测试线程
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程正在执行："+i);
}
}
}
执行效果：
3.3 实现Runnable接口
3.3.1 FutureTask介绍
Callable需要使用FutureTask类帮助执行，FutureTask类结构如下：
Future接口：
判断任务是否完成：isDone()
能够中断任务：cancel()
能够获取任务执行结果：get()
3.3.2. 第一步：创建自定义类实现Callable接口
package com.mall.thread;
import java.util.concurrent.*;
/**
* @Auther: mengyang
* @Date: 2020/1/20 0020 14:37
* @Description: 实现callable接口创建线程
* @statement: callable接口是有返回值的
*/
public class MyCallnable implements Callable<String> {
public String call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println("myCallable线程正在执行："+i);
}
return "MyCallabe线程执行完毕";
}
//测试
public static void main(String[] args) {
//创建futuretask对象
FutureTask<String> futureTask = new FutureTask<String>(new MyCallnable());
//创建Thread对象，传入futureTask
Thread thread=new Thread(futureTask);
thread.start();
for (int i = 0; i<10; i++){
System.out.println("主线程正在执行："+i);
}
}
}
运行效果如下：
3.4. 线程池-Executor
3.4.1. 线程池线类关系图
Executor接口：
声明了execute(Runnable runnable)方法，执行任务代码
ExecutorService接口：
继承Executor接口，声明方法：submit、invokeAll、invokeAny以及shutDown等
AbstractExecutorService抽象类：
实现ExecutorService接口，基本实现ExecutorService中声明的所有方法
ScheduledExecutorService接口：
继承ExecutorService接口，声明定时执行任务方法
ThreadPoolExecutor类：
继承类AbstractExecutorService，实现execute、submit、shutdown、shutdownNow方法
ScheduledThreadPoolExecutor类：
继承ThreadPoolExecutor类，实现ScheduledExecutorService接口并实现其中的方法
Executors类：
提供快速创建线程池的方法
3.4.2. 第一步：创建自定义类实现Runnable接口
package com.mall.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Auther: mengyang
* @Date: 2020/1/20 0020 14:43
* @Description:使用线程池创建线程
* @statement:
*/
public class MyExecutors {
//实现runnable接口,线程池只支持runnable和callable
static class MyRunnable implements Runnable{
public void run() {
for (int i = 0; i<10; i++){
System.out.println("myRunnable线程正在执行："+i);
}
}
}
//测试用线程池创建线程
public static void main(String[] args) {
//1.使用Executors创建线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
//2.通过线程池执行线程,线程池只支持runnable和callable
executorService.execute(new MyRunnable());
//3.主线程循环打印
for (int i=0; i<10; i++){
System.out.println("main主线程正在执行："+i);
}
}
}
实现效果如下：
4、小结
4.1. 实现接口和继承Thread类比较
l 接口更适合多个相同的程序代码的线程去共享同一个资源。
l 接口可以避免java中的单继承的局限性。
l 接口代码可以被多个线程共享，代码和线程独立。
l 线程池只能放入实现Runable或Callable接口的线程，不能直接放入继承Thread的类。
扩充：
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。
4.2. Runnable和Callable接口比较
相同点：
l 两者都是接口；
l 两者都可用来编写多线程程序；
l 两者都需要调用Thread.start()启动线程；
不同点：
l 实现Callable接口的线程能返回执行结果；而实现Runnable接口的线程不能返回结果；
l Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的不允许抛异常；
l 实现Callable接口的线程可以调用Future.cancel取消执行 ，而实现Runnable接口的线程不能
注意点：
Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！