座右铭: 天行健，君子以自强不息;地势坤，君子以厚德载物.
引入进程这个概念的目的
引入进程这个概念,最主要的目的,是为了解决"并发编程"这样的问题.
这是因为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
创建线程,是希望线程成为一个独立的执行流,它要能够执行一段代码.
第一个多线程程序
代码如下:
java
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中创建线程的多种写法
-
继承Thread,重写run方法
1.继承 Thread 来创建一个线程类
2.创建 MyThread 类的实例
3.调用 start 方法启动线程
javaclass 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(); } } -
实现Runnable 接口
1.实现 Runnable 接口
2.创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数
3.调用 start 方法
Runnable 作用，是描述一个"要执行的任务",run方法就是任务的执行细节
javaclass 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(); } }这样写的好处:
解耦合.目的就是为了让线程和和线程要干的活之间分离开.
未来如果要改代码,不用多线程,使用多进程,或者线程池,或者协程...此时代码改动比较小.
-
使用匿名内部类, 继承 Thread
1.创建了一个Thread的子类.(子类没有名字)所以才叫做"匿名"
2.创建了子类的实例,并且让t引用指向该实例
javapublic class ThreadDemo3 { public static void main(String[] args) { Thread t = new Thread(){ @Override public void run() { System.out.println("hello"); } }; t.start(); } } -
使用匿名内部类, 实现 Runnable
这个写法和方法2本质相同.
只不过是把实现Runnable任务交给匿名内部类的语法.
此处是创建了一个类,实现 Runnable,同时创建了类的实例,并且传给Thread的构造方法.
javapublic class ThreadDemo4 { public static void main(String[] args) { Thread t =new Thread(new Runnable() { @Override public void run() { System.out.println("hello"); } }); t.start(); } } -
使用Lambda表达式 ~~ 最简单,推荐使用的写法
把任务用lambda表达式来描述
直接把 lambda传给Thread构造方法.
lambda就是个匿名函数(没有名字的函数)用一次就销毁了.
Java里面函数没法脱离类存在.java为了能和别的语言对齐, 搞了个蹩脚的函数式接口,通过这个来实现lambda .
javapublic class ThreadDemo5 { public static void main(String[] args) { Thread t = new Thread(()-> { System.out.println("hello"); }); t.start(); } }