进程和线程
在学习线程之前，首先要理解什么是进程。打开你的任务管理器，导航栏第一个清清楚楚的写着进程，点进去会发现是许许多多的你在运行的程序，这就是一个进程。
like this:
现代操作系统都可以同时执行多个程序，这就是多任务。线程时建立在进程的基础上的，比如QQ音乐这个进程可以同时在执行播放、下载、传输等动作。这就叫多线程，每个线程在执行不同的功能。
在单核CPU系统中，也可以同时运行多个程序，程序运行是抢占式的，QQ运行0.001S,chrome运行0.01s,这个时间人是感知不出来的，我们就会觉得在同时执行。所以为了提高效率，现在的手机、电脑都是非常多核的。
进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。
操作系统调度的最小任务单位其实不是进程，而是线程。
进程 VS 线程
进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由线程实现，还可以混合多进程+多线程。
和多线程相比，多进程的缺点是：
创建进程比创建线程开销大很多，尤其是在Windows上
进程间通信比线程要慢，因为线程见通信就是读写同一个变量，速度很快
多进程的优点：
多进程稳定性比多线程高，因为在多进程情况下，一个进程的崩溃不会影响其他进程，任何一个线程崩溃会导致整个进程崩溃。
创建线程
1. Thread
例：
public class MyThread extends Thread { // 线程的主体类
@Override
public void run(){
System.out.println("Thread is starting");
}
}
上面的MyThread类继承Thread,覆写了run方法。一个类只要继承了此类，就表示这个类为线程的主体类。run()是线程的主方法,多线程要执行的方法都在这写。
但是run()方法是不能被直接调用的，这牵涉到系统的资源调度问题，想要启动多线程，必须用start()完成。
调用线程
public class ThreadDemo {
public static void main(String[] args) {
new MyThread().start();
// 启动新线程
}
java语言内置了多线程支持。当Java程序启动的时候其实是启动了一个JVM进程。JVM启动主线程来执行main()方法，在main()方法中可以启动其他线程。
start() 只能由 Thread类型实例调用，表示启动一个线程。
执行结果
"C:\Program Files\Java\jdk1.8.0_221\bin\java.exe"
Thread is starting
由此可见，线程创建成功
那么创建一个多线程呢？
创建多线程
// 多线程主体类
public class MyThread extends Thread {
private String title;
public MyThread(){
}
MyThread(String title){
this.title = title;
}
@Override
public void run(){
for (int i = 0; i<10;i++){
System.out.println(this.title + "is starting");
System.out.println(Thread.currentThread().getName());
}
}
}
public static void main(String[] args) {
new Thread(new MyThread("A"),"线程1").start();
new Thread(new MyThread("C"),"线程2").start();
new Thread(new MyThread("B")).start();
}
执行结果：
这个结果中有几个关注点：
多线程的执行是无序的，不可控的
调用的是start()方法，但执行的是run()方法
我们来看一下源码，分析一下
public synchronized void start() {
if (threadStatus != 0) // 判断线程状态
// 每一个线程的类的对象只允许启动一次，重复启动就会抛出这个异常，由run()抛出
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
// 调用此方法
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
private native void start0();
// 注释部分被我删掉了，太长了
我们发现start()方法调用的是start0()，而start0()并没有实现，还被native修饰，那么native是啥呢？
在Java程序执行的过程中考虑到对于不同层次的开发者需求，支持了本地的操作系统函数调用。这项技术被称为JNI(Java Native Interface)，但在Java开发过程中并不推荐这样使用。利用这项技术，可以利用操作系统提供的的底层函数，操作一些特殊的处理。
不同的系统在进行资源调度的时候由自己的一套算法，要想调用start()方法启动线程，就要实现start0()，这时候JVM就会根据不同的操作系统来具体实现start0()，总结就是一切的一切都是跨平台带来的。
这也规定了，启动多线程只有一种方案，调用Thread类中的start()方法.
Thread 构造函数可以接收一个实例对象和线程的名字参数。
Thread.currentThread().getName() 就代表了获取当前线程的名字。
在返回值中还出现了"Thread-3",这是由于Thread会自动给没有命名的线程分配一个不会重复的名字。
这种方式启动多线程固然没错，但存在单继承的隐患。下面就给出另一种模式。
2. Runnable
首先分别来看一下Thread类的实现
public
class Thread implements Runnable {}
原来Thread是继承了Runnable
再看一下Runnable接口
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface
Runnable is used
* to create a thread, starting the thread causes the object's
*
run method to be called in that separately executing
* thread.
*
* The general contract of the method run is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
再次惊讶，原来这个run方法也是从这里继承的。
那就清楚了，来试一下吧。
// 只需要实现 Runnable，重写run()即可，其他丝毫未变
public class MyThread implements Runnable {
private String title;
public MyThread(){
}
MyThread(String title){
this.title = title;
}
@Override
public void run(){
for (int i = 0; i<10;i++){
System.out.println(this.title + "is starting");
System.out.println(Thread.currentThread().getName());
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
new Thread(new MyThread("A线程"),"线程1").start();
new Thread(new MyThread("C线程"),"线程2").start();
new Thread(new MyThread("B线程")).start();
// lambda 语法实现
// new Thread(() -> {
// System.out.println("启动新的线程");
// }).start();
}
}
结果：
完全一致。
在以后的多线程设计实现，优先使用Runnable接口实现。
还没完，我们依靠Runnable接口实现的时候，会发现有一个缺陷，就是没有返回值，那有没有带返回值的实现方式呢？有！继续看
3. Callable
在Java1.5之后为了解决run()方法没有返回值的问题，引入了新的线程实现java.util.concurrent.Callable接口.
我们看一下Oracle的api文档：
可以看到Callable定义的时候利用了一个泛型，代表了返回数据的类型，避免了向下转型带来的安全隐患
了解向下转型可以看我的另一篇文章：https://www.cnblogs.com/gyyyblog/p/11806601.html
但是问题又来了，我们上面已经说过了，要想启动多线程，必须使用Thread类提供的
start() 方法调用Runnable接口的 run() 方法，可是现在 Callable中并没有run() 方法，那怎么办呢？
再来找到一个FutureTask类：
public class FutureTask
extends Object
implements RunnableFuture
构造方法：
它的构造方法可以接收一个Callable类型参数
它又继承了RunnableFuture,那就继续往上找
public interface RunnableFuture
extends Runnable, Future
出现了，它出现了，Runnable我们知道了，是没有返回值的，现在看看Future是个啥
它有一个get()方法可以得到一个泛型返回值。
OK，现在我们就可以梳理一下找到的这些东西怎么个关系：
具体实现
public class CallableThread implements Callable { // 继承实现Callable
// 覆写call()方法
@Override
public String call() throws Exception{
for (int i = 0;i<10;i++){
System.out.println("*********线程执行、i="+ i);
}
return "线程执行完毕";
}
}
// 调用
FutureTask task = new FutureTask<>(new CallableThread());
new Thread(task).start();
System.out.println("【线程返回数据】" + task.get());
结果：
为了得到一个返回值可真不容易，核心思想还是实例化一个Thread对象，可通过其构造方法接收一个Rannable类型参数，调用start()启动线程.
总结：基本来说就这三种创建多线程模式，根据场景使用。https://www.cnblogs.com/gyyyblog/p/11823842.html