进程/线程/纤程/中断/内存管理

最新推荐文章于 2024-08-14 23:12:09 发布

凹凸曼蓝博one

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量679

点赞数

分类专栏：底层知识文章标签： java 后端线程进程内存管理

本文链接：https://blog.csdn.net/weixin_45240169/article/details/122095103

版权

底层知识专栏收录该内容

8 篇文章 1 订阅

订阅专栏

文章目录

进程

linux中也称为task，是系统分配资源的基本单位
资源：独立的地址空间内核数据结构（进程描述符…）全局变量数据段…
进程描述符：PCB（Process Control Block）

线程

线程在linux中的实现：
《linux内核设计与实现》第三版28页讲到：
线程就是一个普通进程，只不过和其他进程共享资源（内存空间全局数据等…）
其他系统都有各自的所谓LWP的实现 Light Weight Process
高层面理解：一个进程中不同的执行路线

面试高频：进程和线程有什么区别？
答案：进程就是一个程序运行起来的状态，线程是一个进程中的不同的执行路径。
专业点说：进程是OS分配资源的基本单位，线程是执行调度的基本单位。分配资源最重要的是：独立的内存空间，线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）

纤程

纤程：用户态的线程，线程中的线程，切换和调度不需要经过OS
优势：
1：占有资源很少 OS : 线程1M Fiber：4K
2：切换比较简单 3：启动很多个10W+

Java中对于纤程的支持：没有内置，可以利用第三方库Quaser（并不成熟）

<dependency>
    <groupId>co.paralleluniverse</groupId>
    <artifactId>quasar-core</artifactId>
    <version>0.8.0</version>
</dependency>

案例：
使用线程的模式：

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.SuspendableRunnable;

public class HelloFiber {

    public static void main(String[] args) throws  Exception {
        long start = System.currentTimeMillis();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                calc();
            }
        };
        int size = 10000;
        Thread[] threads = new Thread[size];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(r);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].join();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    static void calc() {
        int result = 0;
        for (int m = 0; m < 10000; m++) {
            for (int i = 0; i < 200; i++) result += i;

        }
    }
}

使用纤程的模式：

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.SuspendableRunnable;

public class HelloFiber2 {

    public static void main(String[] args) throws  Exception {
        long start = System.currentTimeMillis();
        int size = 10000;
        Fiber<Void>[] fibers = new Fiber[size];
        for (int i = 0; i < fibers.length; i++) {
            fibers[i] = new Fiber<Void>(new SuspendableRunnable() {
                public void run() throws SuspendExecution, InterruptedException {
                    calc();
                }
            });
        }
        for (int i = 0; i < fibers.length; i++) {
            fibers[i].start();
        }
        for (int i = 0; i < fibers.length; i++) {
            fibers[i].join();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    static void calc() {
        int result = 0;
        for (int m = 0; m < 10000; m++) {
            for (int i = 0; i < 200; i++) result += i;
        }
    }
}

纤程适用于：很短的计算任务，不需要和内核打交道，并发量高！

僵尸进程孤儿进程

什么是僵尸线程
父进程产生子进程后，会维护子进程的一个PCB结构，子进程退出，由父进程释放如果父进程没有释放，那么子进程成为一个僵尸进程

什么是孤儿线程
子进程结束之前，父进程已经退出，孤儿进程会成为init进程的孩子，由1号进程维护

进程调度

CFS调度策略：Completely Fair Scheduler
按优先级分配时间片的比例，记录每个进程的执行时间，如果有一个进程执行时间不到他应该分配的比例，优先执行

中断

硬件跟操作系统内核打交道的一种机制
软中断（80中断） == 系统调用
系统调用：int 0x80 或者 sysenter原语
通过ax寄存器填入调用号
参数通过bx cx dx si di传入内核
返回值通过ax返回

java读网络 – jvm read() – c库read() - > 内核空间 -> system_call() （系统调用处理程序）-> sys_read()

内存管理

DOS时代 - 同一时间只能有一个进程在运行（也有一些特殊算法可以支持多进程）
windows9x - 多个进程装入内存 1：内存不够用 2：互相打扰
在这里插入图片描述

为了解决这两个问题，诞生了现在的内存管理系统：虚拟地址->分页装入 ->软硬件结合寻址

分页（解决内存不够用），内存中分成固定大小的页框（4K），把程序（硬盘上）分成4K大小的块，用到哪一块，加载那一块，加载的过程中，如果内存已经满了，会把最不常用的一块放到swap分区，把最新的一块加载进来，这个就是著名的LRU算法
LR：Least Recently Used 最不常用
哈希表（保证查找操作O(1)） + 链表（保证排序操作和新增操作 O(1)））
双向链表（保证左边指针指向右边块）
在这里插入图片描述

虚拟内存（解决相互打扰问题）
DOS Win31 … 互相干掉
为了保证互不影响 - 让进程工作在虚拟空间，程序中用到的空间地址不再是直接的物理地址，而是虚拟的地址，这样，A进程永远不可能访问到B进程的空间
虚拟内存好处：
隔离应用程序
– 每个程序都认为自己有连续可用的内存
– 突破物理内存限制
– 应用程序不需要考虑物理内存是否够用，是否能够分配等底层问题
安全
– 保护物理内存，不被恶意程序访问

内存地址映射：
在这里插入图片描述
虚拟空间多大呢？寻址空间 - 64位系统 2 ^ 64，比物理空间大很多，单位是byte站在虚拟的角度，进程是独享整个系统 + CPU
内存映射：偏移量 + 段的基地址 = 线性地址（虚拟空间）
线性地址通过 OS + MMU（硬件 Memory Management Unit）

缺页中断（不是很重要）：
需要用到页面内存中没有，产生缺页异常（中断），由内核处理并加载

内核同步机制

临界区（critical area）: 访问或操作共享数据的代码段，简单理解：synchronized大括号中部分（原子性）
竞争条件（race conditions）两个线程同时拥有临界区的执行权
数据不一致：data unconsistency 由竞争条件引起的数据破坏
同步（synchronization）避免race conditions
锁：完成同步的手段（门锁，门后是临界区，只允许一个线程存在），上锁解锁必须具备原子性
原子性（象原子一样不可分割的操作）
有序性（禁止指令重排）
可见性（一个线程内的修改，另一个线程可见）
互斥锁排他锁共享锁分段锁

内核同步常用方法

1.原子操作 – 内核中类似于AtomicXXX，位于<linux/types.h>

2.自旋锁 – 内核中通过汇编支持的cas，位于<asm/spinlock.h>

3.读-写自旋 – 类似于ReadWriteLock，可同时读，只能一个写
读的时候是共享锁，写的时候是排他锁

4.信号量 – 类似于Semaphore(PV操作 down up操作占有和释放）
重量级锁，线程会进入wait，适合长时间持有的锁情况

5.读-写信号量 – downread upread downwrite upwrite
（多个写，可以分段写，比较少用）(分段锁）

6.互斥体(mutex) – 特殊的信号量（二值信号量）

7.完成变量 – 特殊的信号量（A发出信号给B，B等待在完成变量上）
vfork() 在子进程结束时通过完成变量叫醒父进程类似于(Latch)

8.BKL：大内核锁（早期，现在已经不用）

9.顺序锁（2.6）： – 线程可以挂起的读写自旋锁
序列计数器（从0开始，写时增加(+1)，写完释放(+1)，读前发现单数，
说明有写线程，等待，读前读后序列一样，说明没有写线程打断）

10.禁止抢占 – preempt_disable()

11.内存屏障 – 见volatile

凹凸曼蓝博one

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
进程/线程/纤程/中断/内存管理

面试高频：进程和线程有什么区别？答案：进程就是一个程序运行起来的状态，线程是一个进程中的不同的执行路径。专业点说：进程是OS分配资源的基本单位，线程是执行调度的基本单位。分配资源最重要的是：独立的内存空间，线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）纤程：用户态的线程，线程中的线程，切换和调度不需要经过OS优势：1：占有资源很少 OS : 线程1M Fiber：4K2：切换比较简单 3：启动很多个10W+Java中对于纤程的支持：没有内置，可以利用第三方库Quaser（并不成
复制链接

扫一扫