备案控制台
开发者社区 龙蜥操作系统 文章 正文

【操作系统】多线程基础知识

2023-08-14 37
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【操作系统】多线程基础知识

思维导图：

 

1.创建线程：

  1. 继承Thread父类，重写run方法。run方法里面的逻辑就是这个线程要执行的工作。创建一个MyThread实例对象不会在系统中真的创建一个线程，只有调用start方法才会创建出新的线程，一直到run里的代码执行完，新的线程就会执行结束。main主线程和MyThread创建出来的新线程是宏观上并发的过程，俩边同时执行各自执行各自的。
1. class MyThread extends Thread{
2. @Override
3. public void run() {
4.         System.out.println("线程MyThread的run方法");
5.     }
6. }
7. 
8. public class Demo1 {
9. 
10. public static void main(String[] args) {
11. MyThread myThread = new MyThread();
12.         myThread.start();
13.     }
14. }
  1. 实现Runnable接口，重写run方法。这里把线程要干的工作和线程本身分开了，使用Runnable专门来表示线程要完成的工作，目的是为了解耦合！
1. class MyRunnable implements Runnable{
2. @Override
3. public void run() {
4.         System.out.println("线程MyRunnable的run方法");
5.     }
6. }
7. 
8. public class Demo1 {
9. 
10. public static void main(String[] args) {
11. MyRunnable myRunnable = new MyRunnable();
12. Thread thread = new Thread(myRunnable);
13.         thread.start();
14.     }
15. }
  1. 匿名内部类创建Thread对象
1. public static void main(String[] args) {
2. Thread thread = new Thread(){
3. @Override
4. public void run() {
5.                 System.out.println("匿名内部类创建Thread对象");
6.             }
7.         };
8.         thread.start();
9.     }
  1. 匿名内部类创建Runnable对象
1. public static void main(String[] args) {
2. Thread thread = new Thread(new Runnable() {
3. @Override
4. public void run() {
5.                 System.out.println("匿名内部类创建Runnable对象");
6.             }
7.         });
8. 
9.         thread.start();
10.     }
  1. lambda表达式
1. public static void main(String[] args) {
2. Thread thread = new Thread( ()-> {
3.             System.out.println("lambda表达式创建线程");
4.         });
5.         thread.start();
6. 
7.     }

2.Thread类：

  1. Thread常见的构造方法
方法 说明
Thread(); 创建线程对象
Thread(Runnable); 使用Runnable来创建
Thread(name); 创建对象并命名
Thread(Runnable,name); 使用Runnable来创建并命名

  2. Thread的常见属性。默认创建的线程是前台进程，前台进程会阻止进程退出，如果main运行完了，前台线程还没完，进程不会退出！若是后台线程，如果main等其他前台线程执行完了，这个时候即使后台线程还没有执行完，进程也会退出。当run方法执行完了，内核的线程就销毁了，但是Thread对象还在。
属性 方法 说明
ID getId(); 线程的唯一标识
名称 getName(); 构造方法指定的name
状态 getState(); 线程的状态
优先级 getPriority();
是否是后台线程 isDaemon();
是否存活 isAlive(); run方法是否运行结束
是否被打断 isInterrupted(); 默认为false

  2. 获取当前线程的引用：Thread.currentThread()；

3.启动线程：

  1. 调用start()才会真正的创建线程，在内核里创建PCB。
  2. start和run的区别：直接调用run并没有创建线程，只是在原来的线程中运行代码；调用start则是创建线程，在新的线程中执行代码（和原来的线程是并发的）。

4.中断线程：

  1. 线程的中断本质上仍然是让run方法尽快结束，而不是run执行一半，强制结束。
  2. 方法1:自己直接定义一个标志位
1. public class Demo1 {
2. public static boolean isQuit = false;
3. public static void main(String[] args) {
4. Thread thread = new Thread(()->{
5. while(!isQuit){
6.                 System.out.println("hello thread!");
7. try {
8.                     Thread.sleep(1000);
9.                 } catch (InterruptedException e) {
10. throw new RuntimeException(e);
11.                 }
12.             }
13.             System.out.println("thread线程执行完了！");
14. 
15.         });
16.         thread.start();
17. 
18. 
19. try {
20.             Thread.sleep(1000);
21.         } catch (InterruptedException e) {
22. throw new RuntimeException(e);
23.         }
24. 
25.         isQuit = true;
26.         System.out.println("设置让threat线程结束！");
27.     }
28. }
  1. 方法二：通过interrupt()方法，使用isInterrupted来判定,使用interrupt方法来进行触发中断。如果线程是Runnable状态则设置标志位为true，如果线程是阻塞状态sleep，则会抛出异常，不设置标志位！  在主线程中，通过thread.interrupt();来中断这个线程，如果满足条件则设置标志位true。
1. public class Demo1 {
2. 
3. public static void main(String[] args) {
4. Thread thread = new Thread(()->{
5. //while(!Thread.interrupted()){
6. while(!Thread.currentThread().isInterrupted()){
7. //currentThread是Thread类的静态方法
8.                 System.out.println("hello thread!");
9. try {
10.                     Thread.sleep(1000);
11.                 } catch (InterruptedException e) {
12. // e.printStackTrace();
13. 
14. // [方式一] 立即结束线程
15. break;
16. 
17. // [方式二] 啥都不做, 不做理会. 线程继续执行
18. 
19. // [方式三] 线程稍后处理
20. // Thread.sleep(1000);
21. // break;
22.                 }
23.             }
24.             System.out.println("thread线程执行完了！");
25. 
26.         });
27.         thread.start();
28. 
29. try {
30.             Thread.sleep(1000);
31.         } catch (InterruptedException e) {
32.             e.printStackTrace();
33.         }
34. 
35.         thread.interrupt();
36.         System.out.println("设置让threat线程结束！");
37.     }
38. }

5.线程等待：

  1. 线程之间的调度顺序是不确定的，可以通过join方法来控制线程之间的结束顺序。
  2. 在main方法中调用thread.join()；效果就是让main线程阻塞等待，等到thread执行完了，main才继续执行。
  3. 如果调用join之前，main线程已经结束了，此时就不需要阻塞等待了！
  4. join（）不带时间的版本就是有点“不见不散”的意思，带时间的版本就是类似于“过时不候”。

6.休眠线程：

  1. sleep指定休眠的时间，让线程休息一会（阻塞一会）。操作系统管理这些线程的PCB的时候是有多个链表的。调用了sleep，则这个PCB就会被移动到另外的阻塞队列中，只有就绪队列才会参与调度。
  2. 当sleep的时间到了，PCB就会被移动回之前的就绪队列中，移回就绪队列不代表立即就能够上CPU上执行，还需要看系统什么时候能够调度到这个线程。
  3. sleep（1000），不一定真的休眠1000，一般要略多于1000。

7.线程的状态：

  1. NEW：Thread对象创建出来了，但是线程还没有创建。
  2. TERMINATED：内核的PCB销毁了，但是Thread对象还在。
  3. RUNNABLE：就绪状态（正在CPU上运行或者在就绪队列中排队）。
  4. TIMED_WAITING：按照一定的时间进行堵塞使用.sleep()。
  5. WAITING：特殊的阻塞状态，调用wait。
  6. BLOCKED：等待锁的时候进入的阻塞状态。

 

8.线程安全存在的问题：

看下面代码：正常情况下预期结果是10w，可每次的结果都不是。

1. class Counter{
2. public int count = 0;
3. public void increase(){
4.         count++;
5.     }
6. }
7. public class Demo1 {
8. private static Counter counter = new Counter();
9. private static Counter counter2 = new Counter();
10. 
11. public static void main(String[] args) throws InterruptedException {
12. Thread thread1 = new Thread(()->{
13. for (int i = 0; i < 50000; i++) {
14.                 counter.increase();
15.             }
16.         });
17. Thread thread2 = new Thread(()->{
18. for (int i = 0; i < 50000; i++) {
19.                 counter.increase();
20.             }
21.         });
22. 
23.         thread1.start();
24.         thread2.start();
25. 
26.         thread1.join();
27.         thread2.join();
28. 
29.         System.out.println("Counter:"+ counter.count);
30.     }
31. }
  1. 进行的count++操作，底层是由三条指令在CPU上完成的，第一是把内存的数据读取到CPU寄存器上->load；第二是把CPU的寄存器中的值进行+1->add；第三是把寄存器中的值写回到内存中->save。
  2. 由于当前的俩个线程修改的是一个变量，由于每次修改是三个步骤（不是原子的），由于线程之间的调度顺序不确定。因此俩个线程在真正执行这些操作的时候就会有多种执行的排列顺序！
  3. 整个线程调度过程中，执行的顺序都是随机的。由于在调度过程中出现串行执行的俩种情况次数和其他情况次数不确定，因此得到的结果就是不确定的值，最终结果不会超过10w。

（更多线程安全内容尽在下期博客~）

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

文章标签：
龙蜥操作系统
调度
安全
关键词：
操作系统线程
珠江上上上
目录
相关文章
泡沫o0
|
3天前
|
消息中间件 存储 算法
【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
泡沫o0
84 0
起飞的风筝
|
3天前
|
存储 消息中间件 算法
《操作系统》——进程与线程
《操作系统》——进程与线程
起飞的风筝
90 0
cheems~
|
4天前
|
存储 缓存 安全
浅谈OS进程和线程
浅谈OS进程和线程
cheems~
39 0
技术鱼.
|
4天前
|
Linux 调度
操作系统-线程同步
操作系统-线程同步
技术鱼.
35 0
c清风莫追
|
4天前
|
Linux Shell 调度
操作系统实验一：进程和线程(1）
实验内容 一、进程的创建 编写一段源程序，使用系统调用fork()创建子进程，当此程序运行时，在系统中有父进程和子进程在并发执行。观察屏幕上的显示结果，并分析原因（源代码：forkpid.c）。
c清风莫追
112 0
Mylvzi
|
4天前
|
存储 Java API
操作系统，进程与线程(一)（下）
操作系统，进程与线程(一)（下）
Mylvzi
40 0
dulu~dulu
|
2天前
|
Unix 调度
操作系统（6）----线程相关
操作系统（6）----线程相关
dulu~dulu
8 0
ZShiJ
|
3天前
|
消息中间件 安全 Ubuntu
【操作系统原理】—— 线程同步
【操作系统原理】—— 线程同步
ZShiJ
15 1
turbolove
|
3天前
|
算法 调度
操作系统 -- 进程和线程同步
操作系统 -- 进程和线程同步
turbolove
23 0
wljslmz
|
3天前
|
Go 调度
Go 可以限制运行时操作系统线程的数量吗？
【2月更文挑战第21天】
wljslmz
30 1

龙蜥操作系统

热门文章

最新文章

  • 1
    查看linux操作系统版本：Ubuntu？Centos？还是其他？
  • 2
    【ECS生长万物之开源】部署MySQL数据库（Linux）
  • 3
    【Anolis OS】龙蜥操作系统(Anolis OS) 8.6安装指南
  • 4
    Linux环境下Docker的卸载
  • 5
    Linux教程丨使用rsync在服务器中高效传输文件，断点续传快速上传下载数据
  • 6
    部署并使用Docker（Alibaba Cloud Linux 3）
  • 7
    Win11彻底卸载WSL2系统（去除导航窗格Linux图标）
  • 8
    Linux版百度网盘丨直接在服务器SSH命令行中使用百度云，轻松解决数据传输和分享难题
  • 9
    深入解析Linux下的struct tm结构体：时间信息的存储与操作
  • 10
    Linux MIPI DSI驱动调试笔记-设备树DCS格式序列之配置LCD初始化代码(二)
  • 1
    高性能网络SIG月度动态：两大特性合入 Linux 主线，提供高速本地通信加速及丰富的设备信息
    6
  • 2
    基于龙蜥衍生版 KeyarchOS 的 LVM 卷管理技术与实践 | 干货推荐
    12
  • 3
    浪潮信息-龙蜥技术认证上线，培训专场圆满召开
    16
  • 4
    高性能存储 SIG 月度动态：多项内核特性移植到 6.6，erofs 完成共享特性 POC
    15
  • 5
    高手竞技！中国研究生创新实践系列大赛&龙蜥赛题等你来挑战
    24
  • 6
    EtherCAT主站IgH解析(一)--主站初始化、状态机与EtherCAT报文
    32
  • 7
    【xenomai3内核解析】系列文章大纲
    16
  • 8
    ARM平台内存和cache对xenomai实时性的影响
    14
  • 9
    xenomai内核解析--双核系统调用(二)--应用如何区分xenomai/linux系统调用或服务
    28
  • 10
    RTnet – 灵活的硬实时网络框架
    19

    • 相关课程

    更多
  • 操作系统学习
  • Linux操作系统实战
  • 高校精品课-西安电子科技大学 -操作系统课程设计
  • Linux基础知识
  • 计算机基础与Linux入门

    • 相关电子书

    更多
  • 开放算力·云启未来
  • 2022龙蜥操作系统生态用户实践精选
  • 冬季实战营第二期：Linux操作系统实战入门

    • 相关实验场景

    更多
  • ECS操作系统无法登录诊断能力
  • ECS操作系统故障诊断能力
  • 基于Conditions在不同操作系统创建ECS
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序
  • 基于Anolis OS 3快速搭建LNMP环境制作KodBox
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考