多线程的学习上篇

座右铭: 天行健，君子以自强不息;地势坤，君子以厚德载物.

引入进程这个概念的目的

引入进程这个概念,最主要的目的,是为了解决“并发编程"这样的问题.
这是因为CPU进入了多核心的时代
要想进一步提高程序的执行速度,就需要充分的利用CPU 的多核资源

其实,多进程编程,已经可以解决并发编程的问题了.已经可以利用起来CPU多核资源了.
但是它带来了新的问题 => 那就是进程太重了(消耗资源多&速度慢)!!!
创建一个进程,开销比较大.
销毁一个进程,开销也比较大.
调度一个进程,开销还比较大.

进程虽然能解决问题,但是它不是作为这个问题的最优解法
期望一种开销更小,重量更轻的这样的一个概念来解决这个“并发编程”
因此,线程应运而生!!!线程也叫做“轻量级进程”
它在解决“并发编程”问题的前提下,让创建,销毁,调度的数速度,更快了一些!!!

进程是操作系统中的基本单位.创建进程,就得给它分配一些资源(如内存资源和硬盘资源……)
在分配资源的时候,还得消耗一些时间进程重,主要就是重在"资源分配/回收"上.

为什么线程更轻量???

=> 它把申请资源/释放资源的操作给省下了.

以工厂的扩建为例:
方案一: 在另外的地方,再建一个跟原来工厂一模一样的分厂(工厂二号)
~~ 需要新的场地和新的物流体系,一套新的生产线….
=> 多进程版本的方案

方案二: 在原来工厂上进行扩建,增加一套生产线 ~~ 成本比第一种方案小很多
~~ 场地和物流体系,都是可以复用之前的,只需要一套新的生产线……
~~ 多线程版本的方案 => 此时,只是在第一套生产线的时候,才需要把资源申请到位,
后续再加新的生产线,就复用之前的资源即可.

线程和进程的关系

~~ 是进程包含线程
一个进程可以包含一个线程,也可以包含多个线程.(不能没有)
只有第一个线程启动的时候,开销是比较大的.后续线程就省事了.

同一个进程里的多个线程之间,共用了进程的同一份资源(主要指的是内存和文件描述符表)

• 内存 ~~ 线程1new的对象,在线程2,3,4里都可以直接使用
• 文件描述表 ~~线程1打开的文件,在线程2,3,4里都可以直接使用

操作系统,实际调度的时候,是以线程为单位进行调度的.
(之前那篇博客讲进程调度,相当于每个进程里面只有一个线程这样的情况)

如果每个进程有多个线程了,每个线程是独立在CPU上调度的
=> 线程是操作系统调度执行的基本单位

一个线程可以在多个进程里面嘛?
不可以!!进程和线程是一个—对多的关系.

一个核心上执行的是一个线程.如果你一个进程有两个线程.
线程1可能在核心A上执行,线程2可能在核心B上执行.
操作系统调度的时候,其实不关心进程,而是只关心线程

一个线程也是通过一个PCB 来描述的
一个进程里面可能是对应一个PCB,也可能是对应多个PCB
之前介绍的,PCB里的状态,上下文,优先级,记账信息,都是每个线程有自己的.各自记录各自的.
但是同一个进程里的PCB之间,pid是一样的,内存指针和文件表述表也是一样的
=> 根据相同的pid来区分他们是同一个进程的.

谈到"调度”已经和进程没啥关系了.
进程专门负责资源分配.
线程来接管和调度相关的一切内容.

理论是为了指导我们编程的,不懂这个理论,
就不知道这个代码为什么这么写!!!

图示理解

最初的需求
1个滑稽老铁,吃100只鸡 ~~ 效率比较低

如何吃得快点,有多进程和多线程两个版本,如下图:
多进程吃鸡的方式:
~~ 成本比较高

多线程吃鸡的方式:

提高这里滑稽老铁的个数,速度能否更快了???

但是如果继续提高滑稽老铁的个数了???

(1)在多线程的情况下,多个滑稽老铁,共享同一份鸡肉,此时就可能会打架

(2)多线程还有一个情况 ~~

注: chrome浏览器要使用多进程编程模型(每个标签页都是个进程)
~~ 目的就是为了防止,一个页面挂了把别的页面带走.

什么时候会存在安全问题???

多个执行流访问同一个共享资源的时候.
~~ 线程模型,天然就是资源共享的.多线程争抢同一个资源(同一个变量)非常容易触发的.
~~ 进程模型,天然是资源隔离的,不容易触发.
进行进程间通信的时候,多个进程访问同一个资源,可能会出问题.

多线程会提高效率,但是不如多进程安全.
但是代码写的好,线程安全问题,就不怕
=> 当前多线程的编程模型,要比多进程这种模型应用更加广泛.
工作中遇到多线程的情况也要比多进程多很多.尤其是Java圈子.

面试中,进程和线程的区别,就是"操作系统"这个模块最高频的问题,没有之一!!!

---

---

---

在Java中如何进行多线程编程

本身关于线程的操作,都是操作系统提供的API
Java是个跨平台的语言.很多操作系统的提供的功能,都被JVM给封装好了.
咱们不需要学习系统原生API,只需要学习Java提供的API就行了.

---

Java是如何实现跨平台的???

• windows系统,实现了一个windows版本的JVM

• Linux系统,实现了Linux版本的JVM

• Mac系统,实现了Mac 版本的JVM

• 随便某个系统, 也实现了对应版本的JVM

跨平台是靠无数个不同版本的JVM支持的!
这些不同的JVM内部封装了不同系统的API,对上都是执行同样规则的字节码
例子: 你去欧洲周游,到各个国家打卡
到了英国,就去请一个英国的翻译(既会说英语,也会说汉语),帮助我与本地人沟通;
到了法国,就又找一个法国的翻译(既会说法语,也会说汉语),帮助我与本地人沟通;
到了德国,就又找一个德国的翻译(既会说德语,也会说汉语),帮助我与本地人沟通;
………
Java跨平台,就于有几个平台,就有几个“翻译”…
~~ 点评: “大力出奇迹!!!”

---

Java操作多线程,最核心的类Thread

~~ 使用Thread类,不需要import别的包,因为它在java.lang下面的
类似的有: String, StringBuilder, StringBuffer

创建线程,是希望线程成为一个独立的执行流,它要能够执行一段代码.

第一个多线程程序

代码如下:

class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
            // 为了让这里的打印慢点, 方便看, 加个sleep, 休眠 1s
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();

        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

运行结果:

操作系统调度线程的时候,“抢占式执行”，具体哪个线程先上,哪个线程后上,不确定,取决于操作系统调度器具体实现策略.
虽然有优先级,但是在应用程序层面上无法修改.
从应用程序(代码)的角度,看到的效果,就好像是线程之间的调度顺序是"随机"的一样.
=> 内核里本身并非是随机.但是干预因素太多,并且应用程序这一层也无法感知到细节,
就只能认为是随机的了!!!
执行顺序是由内核实现的,无解,但可以通过一些API进行有限度的干预.
线程安全问题的罪魁祸首,万恶之源,就是这里的抢占式执行,随机调度.

这里的Thread类,本质上还是系统里的线程的封装.
每个Thread的对象就对应到系统中的—个线程(也就对应一个PCB).

方法重写 Override: 父类有个方法,子类搞一个名字相同,参数也完全相同方法。
子类的方法就会被动态绑定的机制,被调用到.
Thead t = new MyThread();
t.run(); 虽然t是父类引用,此处调用的run仍然是子类的方法.(t本质上还是指向的子类的对象)

重载 Overload: 同一个作用域，多个方法,名字相同,参数个数或者类型不同,
同一个类里,或者是子类和父类之间…

t.sart(); => 线程中的特殊方法,启动一个线程.
start 里面没有调用run,而是创建了个线程.由新的线程来执行run方法.
start如何创建新的线程 => 就是调用操作系统的API,
通过操作系统内核创建新线程的 PCB(程序控制块),并且把要执行的指令交给这个PCB.
当 PCB 被调度到CPU上执行的时候,也就执行到了线程run方法中的代码了
如果run方法执行完毕,新的这个线程自然销毁.

new Thread对象这个操作不创建线程.(这里说的线程指的是系统内核里的PCB)
调用start才是创建的PCB,这才有货真价实的线程的.

start 和 run之间的区别:
start是真正创建了一个线程(从系统这里创建的)，线程是独立的执行流.
run 只是描述了线程要干的活是啥.如果直接再main中调用run, 此时没有创建新线程，全是main线程一个人干活.

PCB对应的是线程.一个线程对应一个PCB一个进程对应多个PCB.
如果一个进程只有一个线程,就是一个进程对一个PCB了.
同一个进程里的若干PCB pid相同.不同进程的pid是不同的.
PCB不是"简称",是一个数据结构,体现的是进程/线程是如何实现,如何被描述出来的.
PCB只是操作系统书里说的概念.实际上Linux对应结构体名字叫做task_struct

如何直观的看到上述代码中的两个线程???
可以使用JDK自带的工具 jconsole 查看当前的Java进程中的所有线程.

注: JDK => Java开发工具包,这里带的工具很多的,不只是javac和java.

注:进程包含线程 => 要想看到线程,得先找到对应的进程,再看进程里有哪些线程.

点击一下上图中的thread.ThreadDemo1

如果你打开JConsole,在本地进程什么都看不到,尝试右键,以管理员方式运行.

---

---

Java中创建线程的多种写法

1. 继承Thread,重写run方法

   1.继承 Thread 来创建一个线程类
   2.创建 MyThread 类的实例
   3.调用 start 方法启动线程

   
   class MyThread extends Thread{
       @Override
       public void run() {
           System.out.println("hello thread");
       }
   }
   public class ThreadDemo1 {
       public static void main(String[] args) {
           Thread t = new MyThread();
           t.start();
       }
   }
   

2. 实现Runnable 接口

   1.实现 Runnable 接口
   2.创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数
   3.调用 start 方法

   Runnable 作用，是描述一个"要执行的任务",run方法就是任务的执行细节

   class MyRunnable implements Runnable {
       @Override
       public void run() {
           System.out.println("hello thread");
       }
   }
   public class ThreadDemo2 {
       public static void main(String[] args) {
           // 这只是描述了一个任务
           Runnable runnable = new MyRunnable();
           // 把任务交给线程来执行
           Thread t = new Thread(runnable);
           t.start();
       }
   }
   

   这样写的好处:
   解耦合.目的就是为了让线程和和线程要干的活之间分离开.
   未来如果要改代码,不用多线程,使用多进程,或者线程池,或者协程…此时代码改动比较小.

3. 使用匿名内部类, 继承 Thread

   1.创建了一个Thread的子类.(子类没有名字)所以才叫做“匿名”
   2.创建了子类的实例,并且让t引用指向该实例

   public class ThreadDemo3 {
       public static void main(String[] args) {
           Thread t = new Thread(){
               @Override
               public void run() {
                   System.out.println("hello");
               }
           };
           t.start();
       }
   }
   

4. 使用匿名内部类, 实现 Runnable

   这个写法和方法2本质相同.
   只不过是把实现Runnable任务交给匿名内部类的语法.
   此处是创建了一个类,实现 Runnable,同时创建了类的实例,并且传给Thread的构造方法.

   public class ThreadDemo4 {
       public static void main(String[] args) {
           Thread t =new Thread(new Runnable() {
               @Override
               public void run() {
                   System.out.println("hello");
               }
           });
           t.start();
       }
   }
   

5. 使用Lambda表达式 ~~ 最简单,推荐使用的写法

   把任务用lambda表达式来描述
   直接把 lambda传给Thread构造方法.
   lambda就是个匿名函数(没有名字的函数)用一次就销毁了.
   Java里面函数没法脱离类存在.java为了能和别的语言对齐, 搞了个蹩脚的函数式接口,通过这个来实现lambda .

   public class ThreadDemo5 {
       public static void main(String[] args) {
           Thread t = new Thread(()-> {
               System.out.println("hello");
           });
           t.start();
       }
   }