目录

一、什么是进程

二、什么是线程

 总结：线程和进程的区别？

三、线程的使用

四、线程的调用

---

一、什么是进程

 进程，也叫任务。就是正常执行的程序。

一个程序有两种状态：

一是没有被执行，在硬盘上躺着的软件；

二是按了exe程序执行的，这时会进入内存，被CPU读取，这就是进程。

二、什么是线程

 为什么需要线程，不直接用进程？

答：咱们之前的代码用的都是一个核心，即使我们再怎么优化，最后也会不够用，而且其他核心都看戏，所以我们需要让多个核心也就是“并发编程”，”多进程编程“其实就是一种典型的并发编程，但是多进程编程太”重“了，创造进程/销毁进程，都是需要重新分配/释放内存的，若要频繁的创建销毁，那就太消耗资源了，随着对效率的要求提升，就需要更好的方式，也就是多线程。

什么是“并行”？

答： 从微观上看，多个核心，一个核心只能处理一个进程，这些核心同时执行，就叫做“并行”

什么是“并行”？

答：从微观上看，一个核心可以“分时复用”执行多个线程，一个接着一个调度CPU上面执行，由于速度够快，宏观上肉眼观察不出来，也就是“并发”。

线程（Thread）是更轻量的进程，开销（时间/空间）比进程少，更适合现在的开发。

一个进程包含多个线程，他们是包含关系。 

线程是“调度执行”的基本单位，

进程是“资源分配”的基本单位。

一个可执行（exe）程序，在被我们双击打开的时候，这个瞬间就会创造一个进程，给这个进程分配很多资源（CPU，内存，硬盘等等）供这个进程使用。这个进程也会创造一个或多个线程，可以去CPU上面调度执行，这些线程共用这一份系统资源。

为什么线程更轻量？

答：一个进程创建需要分配系统资源，而且销毁也需要释放资源。但是我线程是共用这一份资源的，只需要进程创造的时候，创造第一个线程会花点时间，之后创建线程和销毁线程，都是用进程的这一份资源。 

多个线程中，他们有各自的状态，优先级，上下文，记账信息，都会在CPU上面调度执行。 

 举个例子理解多线程和多进程：

假设我有一百只鸡给滑稽老铁吃，就是下面的样子。最外边的框框是房子，中间是桌子，桌子上放着鸡，（像房子和桌子就是我们的系统分配的资源）

假设我这时开辟另一个进程，帮助这个老铁分担压力，注意看，这里进程1和进程2，都是要申请系统资源的（也就是房子和桌子都要分配两份），本来是100只鸡给一个老铁吃，现在是两个老铁吃50只鸡，加快的速度。但是资源的消耗也变大了： 

若是多线程的呢，房子和桌子都是不变的，用的同一个，但是我的滑稽老铁却有2个，这样既可以加快速度也不用多额外的资源，2个人还是吃50只鸡，也同样加快了速度：

  那要是我的滑稽老铁够多了呢，多挤不进去了呢？这样的话，桌子的空间是有限的，就有滑稽老忒吃不到了，也达不到吃鸡的速度了，比如老铁1要吃鸡腿，用手去拿，却被老铁2个抢了，还会引起一些问题~~

也就是说，如果太多了话，就变成抢了。这份资源（内存资源，比如定义的变量/对象）是公用的，假设对同一个变量进行操作（尤其是修改操作）就容易发生冲突，也就是“线程安全问题”。

能提高效率的是充分利用多核心，实现“并发编程”。如果只是微观的“并发”是不能提高编程速度的， 真正能提高速度的是“并行”。如果线程数太多，超过你核心能承受的极限，此时就无法在线程中实现“并行”，也无法达到提高效率，还会引起竞争。

当一个线程发生异常时，就像老铁1吃不到，那也不让别人吃了，把桌子给掀了，得不到就毁掉，也就是“难办就别办了”。要是一个线程出了问题，如果没有即使阻止，可能会连着其他线程一起奔溃：

 总结：线程和进程的区别？

 1）进程包括线程

一个进程可以包含多个线程，但是一个线程只能在一个进程里面，但是一个进程里面至少都要有一个线程。

2）基本单位不同

进程是“资源分配”的基本单位，线程是“调度执行”的基本单位。

3）资源分配不同

一个进程拥有一份内存资源（也就是内存里new出来的对象/变量），每个进程拥有的内存资源都各自一份。但是同一个进程里面的线程是共用一份内存资源的，所以是多个线程用一份资源。

4）多线程在Java圈子是并发编程的主流的编程方式。

主要比进程轻量，多线程可以充分利用好多核心CPU，但是不是越多越好，线程达到一定的数量，就无法继续加快速度了，还会引起一些安全问题。

5）多个线程之间会相互影响。

要是一个线程出现安全问题，没有及时阻止，就可能会一起带走其他线程。

6）进程之间不会影响

进程之间有隔离性，一个进程奔溃了，不会影响到其他进程。

三、线程的使用

 线程本身是操作系统提出的概念，所以我们需要系统提供的原生API，但是这时候问题来了，每个系统提供的API都不一样，那怎么办？

我们JAVA（JVM）中，提供了一套API，也就是JVM封装好的，可以直接使用。

Thread标准库，Thread这个类就负责完成“多线程”相关的开发。

 写法1：

通过创建MyThread这个类，去继承Thread这个类，重写run的方法。然后在main方法里面实例出一个对象，用对象去调用start。就能运行了，在run里面其实写的是要执行的方法，当start后，就开辟线程执行run里面的代码。

为什么不用run却能调用呢？

答：像这样不用手动调用直接可以执行的，这个函数会在合适的时机，被系统/库/框架进行调用了，我们叫做“回调函数”。比如compareTo这个方法。

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class demo1 {
    public static void main(String[] args)  {
        MyThread myThread = new MyThread();
        myThread.start();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

如果我调用run而不是start会怎么样，他们有什么区别？

如上图所示，就是一直打印thread而不是main和thread交替打印，也就是说只有一个线程，就是main线程，在调用这个run这个方法。

这个是调用start方法，这时是交替打印，说明创建了2个线程。如果用run则没有，这也说明了run里面写内容，而start是一个线程的入口。

写法2：

实现Runnable接口，重写run方法，通过Thread的实例，把runnable的实例传进去，在调用start

 线程要执行的程序，用Runnable来描述，而不是用Thread自己来描述。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class demo2 {
    public static void main(String[] args) {
        MyRunnable myRunnable=new MyRunnable();
        Thread t=new Thread(myRunnable);
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 有人认为，这种写法更利于“解耦合”。

这个Runnable是一个任务，并不是和“线程”强相关的。要是后续执行这个任务的载体，可以是线程，也可以是别的东西。

写法3：

本质的写法1的匿名内部类：

public class demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

匿名内部类干了如下：

1）匿名内部类，这个类是thread的子类

2）内部类，重写了run方法

3）创建了子类的实例，并且引用赋值给了t

匿名内部类，用完一次就丢了，是一次性的。

写法4：

 本质的写法2的匿名内部类：

public class demo4 {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t=new Thread(runnable);
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

//也可以
public class demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
              @Override
              public void run() {
                  while (true){
                      System.out.println("hello thread");
                      try {
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          });
       t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

写法5（推荐）：

基于lambda表达式，创建线程：

public class demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

四、线程的调用

当我写下如下代码：

public class demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

然后我一运行，他们是“不确定性的”执行的。并且不只有Thread还有main，也就是说，main是主进程，因为一个进程必须要有一个线程，所以main就是这么一个必须有的。  

线程之间，谁先去CPU上调度执行，这是“不确定的”。（不是数学上的随机），而且取决于操作系统，操作系统里面会有一个“调度器” ，通过它来实现的，他里面有一套规则，我们作为应用软件开发，无法干预，也感受不到，所以我们把这过程，近视称为“随机”。

我们可以通过Jconsole来观察这些线程：

在java-》jdk-》bin-》Jconsole

点开jconsole，选择： 

之后连接，然后上面选择线程：

就可以看到线程都是由Thread-数字，来命名的。

堆栈跟踪就是我们的调用栈，我们是先调用的run，在调用的sleep。因为是栈嘛。

左边的是我们的线程，我们可以发现，我们不止有main（这里太小，没圈全）和thread，还有其他的线程，这些其他的线程是用来辅助的。比如释放资源，显示信息等等....