线程介绍，线程与进程区别，如何使用多线程，Thread类，Runnable接口，补充知识（方法重载，方法重写）

引言：搞进程是为了什么呢？

满足并发编程，这样的需求，cpu多个核心，应用程序做出对应调整，让代码可以把多个核心充分利用起来～，当需要支持多个任务的时候——进程就十分关键了，多进程已经很好的实现了并发编程的效果，但是缺点也很明显，就是太重了,如果我们进程大规模的创建销毁，则开销就会比较大（普通用户一般不会，但是服务器就不一定了）——于是聪明的猿们想了个办法

一、💛线程的介绍

线程（轻量级的进程）：创建进程的时候，只分配自己一个简单的PCB（进程控制块，c,结构）,而不去分配后续的这些内存硬盘资源，这样不就更快了没，这样既可以并发的去执行任务，又可以提升创建/销毁速度。

但是这时候又有疑问了🤔️

只创建一个pcb,没有分配后续，但是线程搞出来就是为了执行任务，执行任务有需要消耗这些资源（不给钱，人家也不能给你干活对吧😶）聪明的猿->

方法：创建的还是进程，创建进程的时候，把资源都分配好～，后续创建的线程，让线程在进程内部（进程和线程之间的关系，可以认为进程包含了线程），后续进程中的新的线程，直接复用前面的进程这里创建好的资源～

其实💨💨一个进程至少包含一个进程，最初创建出来的这个，可以视为是一个只包含一个线程的进程（此时创建需要分配资源，此时第一个线程的开销可能比较大的，但是后续再这个进程里创建进程，就可以省略分配资源的过程，资源是已经有了的

补充：线程也是通过PCB描述的（看出来了某些佬们制作的时候，可能偷懒了，统一设置一样的了，此时一个PCB对应一个线程，多个PCB对应一个进程

⚠️⚠️PCB（线程）内存，指针，文件描述符表，同一个进程的多个PCB这两个字段内容相同，但是上下文，状态，记账信息···PCB支持调度的属性，则这些每个PCB不同。

原因：同一个进程的这些线程，共用一份资源（内存+硬盘），但是每个线程独立去cpu上调度（状态，上下文，优先级，记账信息，各自有各自的一份）

💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖 💖

记住：进程：操作系统进行资源分配的基本单位

           线程：操作系统进行调度执行的基本单位

线程不能太多，线程调度的开销，反而拖慢整个程序效率。

二、线程产生的问题 🌝  🌝

多线程的优势：稳定，一点问题不会发生，多进程的隔离性

1.同时看上一个鸡大腿，两个人可能会冲突，这样的冲突，可能带来bug，线程安全问题（多线程编程里面，最关键的问题）

2.假如有个大哥心情焦躁把桌子掀翻了（乌鸦：难办？难办就都别办了），一旦某个进程，执行过程中出现异常，并且这个异常没有背很好的处理，此时，就可能会导致整个进程终止（进程中的所有进程也就随之终止）

——所以说线程也不一定就比进程更好，只是有优势：更轻量，销毁速度快

多进程，多线程（JAVA常用）多本质并发编程实现模型，实际上，还存在其他并发编程的实现模型。

3.补充 进程1假如访问进程2才叫越界，但是线程1，线程2是共用一个空间。

三、面试经典问题（小总结）😋

谈谈进程和线程的区别和联系

1.进程包含线程，都是为了实现并发编程的方式，线程比进程更加轻量。

2.进程是系统分配资源的基本单位，线程是系统调度执行的基本单位，创建进程的时候把分配资源（虚拟地址空间——内存资源，文件描述符表——硬盘资源）的工作给做了，后续创建线程，直接共用之前的资源即可。

3.进程有独立的地址空间，彼此之间不会相互影响，进程的独立性->系统稳定性，多个进程共用这一份地址空间，一个线程一旦抛出异常，就可能导致整个进程异常结束->多个线程之间

⛄️⛄️⛄️

线程是轻量，但是也有成本，但是在互联网圈子，高并发的服务器太多了，要处理的并发量太多了，非常频繁的创建/销毁线程，开销也不可以被忽视了。聪明的猿们->

两个办法：🐻

1.轻量级编程：协程/纤程                java标准库里，没有配置（目前），有一些第三方库实现了协程，GO天然支持协程（也是热门的一大原因）

2.线程池：池（pool)计算机中非常经典的思想方法，把一些要释放的资源，不着急释放，先放到池子里，以备后续使用，申请资源的时候，也先提前把资源请好，也放到一个池子里面，后续申请的时候也比较方便。

线程～本身是操作系统的概念，操作系统也提供了一些API供猿们使用，java中，把操作系统封装，把操作系统API，又进行封装，提供Thread类。java追求跨平台，JVM 能屏蔽不同操作系统的差异。

另外谈到java简单复习一个小的知识点 🐷方法重载和方法重写（基础，还是很重要的）

方法重载：方法名相同 ，参数列表不同，返回值不作要求

方法重写：是父类和子类之间，子类的方法类似于覆盖这种重写了父亲的方法。方法并且不可以是静态的，子类的访问限定修饰符一定要大于父类的，final修饰的不能被重写，返回值一样的。

myThread.start():创建进程，此处这个start就是在创建进程，🐵（这个操作就会在底层调用操作系统的API，同时还会在操作系统的内核里创建出对应的PCB结构，并且加入对应的链表中···）此时，这个新创建出来的线程，就参与到CPU的调度之中，这个线程接下来要执行的工作，就是上面重写run()这个方法。

那么肯定也有人会有问题，假如说我们使用run（）方法行不行呢 ,  可以，但是二者的区别是，一个使用后是产生了线程，一个就是单纯的使用了普通方法。

 

我们看下图，调整了一下main中有while循环，线程中也存在一个while循环，两个都是死循环，使用start方法执行，（相当于我们创建了一个线程，去执行下面的代码）则两个循环都在执行，是交替来做的，两个线程，分别执行自己的 循环，这两个线程都能参与到cpu的调度之中，这两个线程while循环并发式的执行。

假如说这个地方还用run的话，就是单线程执行，那就会一直执行run方法，并未创建新线程，每个线程都是一个独立执行流，每个线程都可以独自执行一段代码，多个线程之间是并发关系～。

上图的代码自行复制

class MyThread extends  Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world");
        }
    }
}
    public  class  Demo {
        public static void main(String[] args) {
            MyThread myThread = new MyThread();
            myThread.start();
            while (true) {
                System.out.println("love");
            }
        }
    }

创建进程之后，查看线程方法

1.idea调试器 main这个主线程，Thread新的线程

2.jocnsole 找路径去找，SDK，双击本地进程然后去打开，看堆栈跟踪，线程的调用栈，方法之间调用关系，尤其是当前程序basil，查看胰腺癌这里每个线程的调用栈，就可以大概知道，哪个代码出现卡死的情况

介绍一个静态方法(Thread的），java中sleep(让他转的走的慢一点)，🕙🕙🕙Sleep函数可以使计算机程序（进程，任务或线程）进入休眠，使其在一段时间内处于非活动状态。当函数设定的计时器到期，或者接收到信号、程序发生中断都会导致程序继续执行前提.注意继承的类里面只可以try catch处理异常，而不能选择去抛异常（因为他的父类没有抛异常，他这个重写也不可以），但是下面的while是可以抛异常的，因为他不需要继承父类

class MyThread extends  Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world");
            try {
                Thread.sleep(1000);  //必须try catch
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
    public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            myThread.start();
            while (true) {
                System.out.println("love");
                Thread.sleep(1000);      //抛异常，try catch都可以
            }
        }
    }

用完sleep之后，此处也并非是严格的交替，也存在一些顺序反过来的情况，当这两个线程进行sleep之后，就会进入阻塞状态，当时间到，系统会重新唤醒这两个线程，并且恢复对线程的调度，当这两个线程被唤醒，谁先后，可以视为随机。

但其实也不是随机，系统在进行多个线程调度的时候，没有一个明确的顺序，而是按照这样随机的方式进行调度～这样的随机调度的过程，称为抢占式执行。

Java通过Thread创建线程的方式方法，还有很多写法

1.创建一个类，继承Thead,重写run方法

2.创建一个类，实现Runnable（实现interface，Java中interface一般都是形容词词性 哈哈哈没啥用）,重写run方法

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

Runnable,本身没有start方法，绕不开start，这是必须的一步，

Thread是要完成的操作，放到Thread的run中

Runnable这里，则是分开了，要把完成的工作放到Runnable,再让Runnable和Thread配合，

Runnable:好处线程要执行的任务和线程本身，进一步的解耦合了，（相当于把任务和线程拆开了Runnable,并发编程的方式，来完成某个工作具体细节，

使用多线程——使用Runnable搭配线程使用，

线程池——可以使用Runnable搭配线程池使用

协程——--Runnable搭配协程