进程和线程
在学习线程之前，首先要理解什么是进程。打开你的任务管理器，导航栏第一个清清楚楚的写着进程，点进去会发现是许许多多的你在运行的程序，这就是一个进程。
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 <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> 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<V>
extends Object
implements RunnableFuture<V>构造方法：
它的构造方法可以接收一个Callable类型参数
它又继承了RunnableFuture<V>,那就继续往上找
public interface RunnableFuture<V>
extends Runnable, Future<V>出现了，它出现了，Runnable我们知道了，是没有返回值的，现在看看Future<V>是个啥
它有一个get()方法可以得到一个泛型返回值。
OK，现在我们就可以梳理一下找到的这些东西怎么个关系：
具体实现
public class CallableThread implements Callable<String> { // 继承实现Callable<V>
// 覆写call()方法
@Override
public String call() throws Exception{
for (int i = 0;i<10;i++){
System.out.println("*********线程执行、i="+ i);
}
return "线程执行完毕";
}
}
// 调用
FutureTask<String> task = new FutureTask<>(new CallableThread());
new Thread(task).start();
System.out.println("【线程返回数据】" + task.get());结果：
为了得到一个返回值可真不容易，核心思想还是实例化一个Thread对象，可通过其构造方法接收一个Rannable类型参数，调用start()启动线程.
总结：基本来说就这三种创建多线程模式，根据场景使用。
**纯属个人理解，希望指正错误，共同交流。