精华内容
下载资源
问答
  • 操作系统中的进程调度策略哪几

    万次阅读 多人点赞 2018-09-22 09:00:39
    当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。在进程调度中采用FCFS算法时,则每次调度是从就绪...
    1. 先来先服务调度算法:先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
    2. 短作业(进程)优先调度算法:短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
    3. 高优先权优先调度算法:为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入了最高优先权优先(FPF)调度算法。此算法常被用于批处理系统中,作为作业调度算法,也作为多种操作系统中的进程调度算法,还可用于实时系统中。当把该算法用于作业调度时,系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时,该算法是把处理机分配给就绪队列中优先权最高的进程,这时,又可进一步把该算法分成如下两种。
    •     3.1) 非抢占式优先权算法:在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成;或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程。这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中。
    •     3.2) 抢占式优先权调度算法:在这种方式下,系统同样是把处理机分配给优先权最高的进程,使之执行。但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程。因此,在采用这种调度算法时,是每当系统中出现一个新的就绪进程i 时,就将其优先权Pi与正在执行的进程j 的优先权Pj进行比较。如果Pi≤Pj,原进程Pj便继续执行;但如果是Pi>Pj,则立即停止Pj的执行,做进程切换,使i 进程投入执行。显然,这种抢占式的优先权调度算法能更好地满足紧迫作业的要求,故而常用于要求比较严格的实时系统中,以及对性能要求较高的批处理和分时系统中。
    •     3.3)容易出现先级倒置现象:优先级反转是指一个低优先级的任务持有一个被高优先级任务所需要的共享资源。高优先任务由于因资源缺乏而处于受阻状态,一直等到低优先级任务释放资源为止。而低优先级获得的CPU时间少,如果此时有优先级处于两者之间的任务,并且不需要那个共享资源,则该中优先级的任务反而超过这两个任务而获得CPU时间。如果高优先级等待资源时不是阻塞等待,而是忙循环,则可能永远无法获得资源,因为此时低优先级进程无法与高优先级进程争夺CPU时间,从而无法执行,进而无法释放资源,造成的后果就是高优先级任务无法获得资源而继续推进。
    •     3.4)优先级反转案例解释:不同优先级线程对共享资源的访问的同步机制。优先级为高和低的线程tall和线程low需要访问共享资源,优先级为中等的线程mid不访问该共享资源。当low正在访问共享资源时,tall等待该共享资源的互斥锁,但是此时low被mid抢先了,导致mid运行tall阻塞。即优先级低的线程mid运行,优先级高的tall被阻塞。
    •     3.5)优先级倒置解决方案:
    •        (3.5.1)设置优先级上限,给临界区一个高优先级,进入临界区的进程都将获得这个高优先级,如果其他试图进入临界区的进程的优先级都低于这个高优先级,那么优先级反转就不会发生。
    •      (3.5.2)优先级继承,当一个高优先级进程等待一个低优先级进程持有的资源时,低优先级进程将暂时获得高优先级进程的优先级别,在释放共享资源后,低优先级进程回到原来的优先级别。嵌入式系统VxWorks就是采用这种策略。
    •        这里还有一个八卦,1997年的美国的火星探测器(使用的就是vxworks)就遇到一个优先级反转问题引起的故障。简单说下,火星探测器有一个信息总线,有一个高优先级的总线任务负责总线数据的存取,访问总线都需要通过一个互斥锁(共享资源出现了);还有一个低优先级的,运行不是很频繁的气象搜集任务,它需要对总线写数据,也就同样需要访问互斥锁;最后还有一个中优先级的通信任务,它的运行时间比较长。平常这个系统运行毫无问题,但是有一天,在气象任务获得互斥锁往总线写数据的时候,一个中断发生导致通信任务被调度就绪,通信任务抢占了低优先级的气象任务,而无巧不成书的是,此时高优先级的总线任务正在等待气象任务写完数据归还互斥锁,但是由于通信任务抢占了CPU并且运行时间比较长,导致气象任务得不到CPU时间也无法释放互斥锁,本来是高优先级的总线任务也无法执行,总线任务无法及时执行的后果被探路者认为是一个严重错误,最后就是整个系统被重启。Vxworks允许优先级继承,然而遗憾的工程师们将这个选项关闭了。
    •      (3.5.3)第三种方法就是临界区禁止中断,通过禁止中断来保护临界区,采用此种策略的系统只有两种优先级:可抢占优先级和中断禁止优先级。前者为一般进程运行时的优先级,后者为运行于临界区的优先级。火星探路者正是由于在临界区中运行的气象任务被中断发生的通信任务所抢占才导致故障,如果有临界区的禁止中断保护,此一问题也不会发生。

     

           4、高响应比优先调度算法:在批处理系统中,短作业优先算法是一种比较好的算法,其主要的不足之处是长作业的运行得不到保证。如果我们能为每个作业引入前面所述的动态优先权,并使作业的优先级随着等待时间的增加而以速率a 提高,则长作业在等待一定的时间后,必然有机会分配到处理机。该优先权的变化规律可描述为:

           在利用该算法时,每要进行调度之前,都须先做响应比的计算,这会增加系统开销。

           5、时间片轮转法:在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU 分配给队首进程,并令其执行一个时间片。时间片的大小从几ms 到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之,系统能在给定的时间内响应所有用户的请求。

           6、多级反馈队列调度算法:前面介绍的各种用作进程调度的算法都有一定的局限性。如短进程优先的调度算法,仅照顾了短进程而忽略了长进程,而且如果并未指明进程的长度,则短进程优先和基于进程长度的抢占式调度算法都将无法使用。而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。在采用多级反馈队列调度算法的系统中,调度算法的实施过程如下所述。

    • (1) 应设置多个就绪队列,并为各个队列赋予不同的优先级。第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同,在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小。例如,第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍。

    • (2)当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度。当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n 队列便采取按时间片轮转的方式运行。

    • (3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1~(i-1)队列均空时,才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程。

       

       

      批处理系统、分时系统和实时系统中,各采用哪几种进程(作业)调度算法?

      批处理系统常用调度算法:
      ①、先来先服务:FCFS
      ②、最短作业优先
      ③、最短剩余时间优先
      ④、响应比最高者优先

      分时系统调度算法:
      ①、轮转调度
      ②、优先级调度
      ③、多级队列调度
      ④、彩票调度

      实时系统调度算法:
      ①、单比率调度
      ②、限期调度
      ③、最少裕度法

    展开全文
  • 如何确保N线程可以访问N个资源同时又不导致死锁? 答:使用多线程时,一种非常简单的避免死锁的方式就是:指定锁的顺序,并强制线程按照指定的顺序获取锁。因此所有的线程都是以同样的加锁和释放锁,就不会出现...

    转自:牛客网

    如何确保N个线程可以访问N个资源同时又不导致死锁?

    答:使用多线程时,一种非常简单的避免死锁的方式就是:指定锁的顺序,并强制线程按照指定的顺序获取锁。因此所有的线程都是以同样的加锁和释放锁,就不会出现死锁了


    下面是详细解释:

    预防死锁,预先破坏产生死锁的四个条件。互斥不可能破坏,所以有如下3种方法:

    1.破坏  请求和保持条件

    1.1)进程等所有要请求的资源都空闲时才能申请资源,这种方法会使资源严重浪费(有些资源可能仅在运行初期或结束时才使用,甚至根本不使用)

    1.2)允许进程获取初期所需资源后,便开始运行,运行过程中再逐步释放自己占有的资源。比如有一个进程的任务是把数据复制到磁盘中再打印,前期只需要获得磁盘资源而不需要获得打印机资源,待复制完毕后再释放掉磁盘资源。这种方法比上一种好,会使资源利用率上升。

    2.破坏  不可抢占条件

    这种方法代价大,实现复杂

    3.破坏 循坏等待条件

    对各进程请求资源的顺序做一个规定,避免相互等待。这种方法对资源的利用率比前两种都高,但是前期要为设备指定序号,新设备加入会有一个问题,其次对用户编程也有限制




    展开全文
  • 一个线程OOM之后,进程会崩溃么

    千次阅读 2019-07-27 10:51:19
    偶然间看到一个问题,一个线程OOM之后,进程里面的其他线程还能运行吗?看了其他博客里面都说可以运行,但是按照项目上的经验,我们的项目是部署在tomcat中运行,如果发生OOM,这个时候发送请求是不会回应的!所以...

    偶然间看到一个问题,一个线程OOM之后,进程里面的其他线程还能运行吗?看了其他博客里面都说可以运行,但是按照项目上的经验,我们的项目是部署在tomcat中运行,如果发生OOM,这个时候发送请求是不会有回应的!所以本文打算分析一下某个线程内存溢出是,进程中的其他线程到低能否正常运行。

     

    先说下个人测试得出来的结论:

    OutOfMemoryError是一种错误,它是 JVM 的一种自我防御机制,用于防止整个应用程序崩溃,这个时候线程会被Kill掉,然后抛出OutOfMemory异常信息。因为栈上的空间是线程私有的,所以线程被Kill掉之后,栈上的空间就被释放了,但是堆空间是共享的,被Kill掉的线程中的对象可能被该线程之外的其他线程引用,这个时候这部分对象就没有办法被GC掉,其他线程如果此时需要申请资源但是又资源又不足,那么此时其他线程就不能运行

    为什么tomcat内存溢出之后其他请求也无法响应了呢?个人猜测是:OutOfMemory线程所持有的大对象被其他线程引用了,所以GC的时候GC Root链还是可达的,同时其他线程也要使用内存,此时内存不够了,所以其他线程也用不了了。

    要明确的一点是:线程被Kill和内存回收是两件完全不同的事情

     

    个人测试代码如下:

        public static void main(String[] args) {
    
    //        //todo list加在这儿
    //        List<byte[]> list = new ArrayList<>();
    
    
            Thread thread1 = new Thread(new Runnable() {
                //todo list加在这儿
                List<byte[]> list = new ArrayList<>();
    
                @Override
                public void run() {
                    while (true) {
                        System.out.println("Thread1 : now list size is : " + list.size());
                        byte[] b = new byte[1024 * 1024];
                        list.add(b);
    
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    }
                }
            });
    
    
            Thread thread2 = new Thread(() -> {
                while (true) {
                    System.out.println("Hello, this Thread steal alived ");
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
    
            //这个线程也在申请资源
            Thread thread3 = new Thread(new Runnable() {
                //list加在这儿
                List<byte[]> list = new ArrayList<>();
    
                @Override
                public void run() {
                    while (true) {
                        System.out.println("Thread3 : now list size is : " + list.size());
                        byte[] b = new byte[1024 * 1024];
                        list.add(b);
    
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
    
            thread1.start();
            thread2.start();
            thread3.start();
    
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("Main Thread start GC");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.gc();
            }
    
    
        }

    Thread1和Thread3都在申请内存,Thread2只是输出信息。

     

    1. 开启Thread1和Thread2,不显示调用System.gc(),变量为线程是有或者被主线程持有

    线程会被Kill,但是不管变量是否是线程私有的,内存都不会被回收,因为不满足GC条件。图示如下:

     

    2.开始Thread1和Thread2,显示调用System.gc(),变量如果为线程私有的话会被回收,如果还被其他线程持有,那么这部分空间就不会被回收

    引用还被其他线程持有的情况:

    对象为线程私有的情况:

        可以看出,如果对象的引用被其他线程持有,对象是不会被回收的!

     

    3.三个线程都开启,不显示调用System.gc(),对象未线程私有

           Thread1和Thread3会先后发生线程溢出,Thread1在先溢出之后,对象没有被回收,但是Thread3也在持续申请内存。所以Thread3申请不到内存时,JVM会进行一次Full GC,回收Thread1占用的内存好分配给Thread3。Thread3一直申请内存直到内存溢出。

     

    展开全文
  • 设计一个模块,功能是列出系统中所有内核线程的程序名、PID号和进程状态。主要步骤: 阅读内核源代码,了解进程描述符task_struct中与本实验有关的成员项,以及访问进程队列的宏for_each_process; 分析内核模块...

    设计一个模块,功能是列出系统中所有内核线程的程序名、PID号和进程状态。主要步骤:

    阅读内核源代码,了解进程描述符task_struct中与本实验有关的成员项,以及访问进程队列的宏for_each_process

    分析内核模块实例,掌握内核模块的主要构成;

    阅读Makefile文件,理解内核模块编译、加载过程;

    以下是hello.c文件

    #include <linux/sched.h>
    #include<linux/init.h>
    #include<linux/module.h>
    #include<linux/kernel.h>
    //#define for_each_process(p)
    static int hello_init(void)
    {
            struct task_struct *p;
            printk(KERN_ALERT"名称\t进程号\t状态\t");
    //      p=NULL;
            for_each_process(p)
            {
                    printk(KERN_ALERT"%d\t%d\t%d\n",p->comm,p->pid, p->state);
            }
            return 0;
    }
    static void hello_exit(void)
    {
            printk(KERN_ALERT "hello world exit\n");
    }
    module_init(hello_init);//加载函数
    module_exit(hello_exit);                //卸载函数
    MODULE_LICENSE("GPL");  //许可证申明
    MODULE_DESCRIPTION("hello module");

    MODULE_AUTHOR("liguangcai");

    以下是Makefile文件:

    ifneq ($(KERNELRELEASE),)
     obj-m:=readprocess.o
    else
     KDIR:= /lib/modules/$(shell uname -r)/build
     PWD:= $(shell pwd)

    default://注意,default前面最好不要有空格,刚开始做的时候前面加空格报错了
     $(MAKE) -C $(KDIR) M=$(PWD) modules  
    clean:://注意,前面最好不要有空格
     $(MAKE) -C $(KDIR) M=$(PWD) clean
    endif://注意,前面最好不要有空格

    编写完上述两个文件后回到这两个文件所在的目录键入命令: make

    然后:

    #insmod hello.ko

    查看加载模块是否成功:

     #dmesg

    自此实验完成!
     
     
    实验参考:

    一、Linux的内核模块

    内核模块是Linux内核向外部提供的一个插口,其全称为动态可加载内核模块(Loadable Kernel Module,LKM),简称模块。Linux内核之所以提供模块机制,是因为它本身是一个单内核(monolithic kernel)。单内核的最大优点是效率高,因为所有的内容都集成在一起,但其缺点是可扩展性和可维护性相对较差,模块机制就是为了弥补这一缺陷。 

    模块是具有独立功能的程序,它可以被单独编译,但不能独立运行。它在运行时被链接到内核作为内核的一部分在内核空间运行,这与运行在用户空间的进程是不同的。模块通常由一组函数和数据结构组成,用来实现一种文件系统、一个驱动程序或其他内核上层的功能。

    总之,模块是一个为内核(从某种意义上来说,内核也是一个模块)或其他内核模块提供使用功能的代码块。

    1.  利用内核模块的动态装载性的优点: 

    将内核映象的尺寸保持在最小,并具有最大的灵活性;便于检验新的内核代码,而不需重新编译内核并重新引导。 

    2.  内核模块的缺点:

    装入的内核模块和其他内核部分一样,具有相同的访问权限,因此,差的内核模块会导致系统崩溃;为了使内核模块访问所有内核资源,内核必须维护符号表,并在装入和卸载模块时修改这些符号表;有些模块要求利用其他模块的功能,因此,内核要维护模块之间的依赖性。内核必须能够在卸载模块时通知模块,并且要释放分配给模块的内存和中断等资源;内核版本和模块版本的不兼容,也可能导致系统崩溃。

     相关操作说明:

    a、必需模块函数

    加载函数    module_init(hello_init);  

    卸载函数    module_exit(hello_exit);    

    b、可选模块函数

    MODULE_LICENSE(“*******”);    许可证申明

    MODULE_AUTHOR(“********”);    作者申明

    MODELE_DESCRIPTION(“***”);    模块描述

    MODULE_VERSION(“V1.0”);       模块版本

    MODULE_ALIAS("*********");    模块别名

    c、加载内核模块

    载入模块使用insmod命令:

    #insmod hello.ko

    卸载内核模块使用rmmod命令:

    #rmmod hello

    d、查看加载模块是否成功

       dmesg可以看到系统的内核模块信息。

    三、与本次试验相关的内核代码:

    1.  进程控制块的相关内容:

    linux/sched.h文件中:

    #define TASK_RUNNING 0

    #define TASK_INTERRUPTIBLE 1

    #define TASK_UNINTERRUPTIBLE 2

    #define __TASK_STOPPED 4

    #define __TASK_TRACED 8

    #define EXIT_ZOMBIE 16

    #define EXIT_DEAD 32

    #define TASK_DEAD 64

    #define TASK_WAKEKILL 128

    #define TASK_WAKING 256

    #define TASK_PARKED 512

    struct task_struct {

    volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */

    struct list_head tasks;

    struct mm_struct *mm;

    pid_t pid;

    pid_t tgid;

    struct task_struct __rcu *real_parent; /* real parent process */

    struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */

    char comm[TASK_COMM_LEN]; /* executable name excluding path */

    }

    2.  for_each_process(p)宏:

    宏for_each_process(p)的功能是扫描整个进程链表

    #define for_each_process(p) \ for (p = &init_task ; (p = next_task(p)) != &init_task ; )

    使用方法:

    struct task_struct *p;

    for_each_process(p){

    //p指向的进程描述符进行操作

    }


    展开全文
  • 进程同步的几机制

    千次阅读 2018-05-06 00:41:08
     进程互斥是进程之间发生的一种间接性作用,一般是程序不希望的。通常的情况是两或两以上的进程需要同时访问某个共享变量。我们一般发生能够问共享变量的程序段称为临界区。两个进程不能同时进入临界区,否则...
  • 进程的几状态

    万次阅读 2018-06-08 17:05:35
    就绪态:进程已经做好了准备,只要机会就开始执行。阻塞态(等待态):进程在某些事情发生前不能执行,等待阻塞进程的事件完成。新建态:刚刚创建的进程,操作系统还没有把它加入到可执行进程组中,通常是进程控制...
  • 故障现象: 1、某分行部署的某台服务器内存占用过高,导致死机;...在crontab 中发现脚本每天14点进行FTP批量数据传输,找到相应的传输文件存放目录发现每天传输的文件达到30多G,由此可判断这就是故障之根
  • Linux - 进程() 进程空间

    千次阅读 2014-09-06 13:19:44
    Linux 进程空间介绍
  • CPU由一个进程快速切换至另一个进程,使得每个进程运行几十或几百毫秒,从而产生一种并行的错觉。 进程模型 一个进程就是一个正在执行程序的实例,包括程序计数器、寄存器和变量当前值。从概念...
  • kswapd进程cpu使用高导致死机

    千次阅读 2017-03-01 12:11:17
    ubuntu内核更新到4.4.0-51之后,系统莫名出现死机,不定时的kswapd进程占用CPU,原因如下 physical mem 不足,引起 swap 频繁读写。 kswapd0 是系统的虚拟内存管理程序,如果物理内存不够用,系统就会唤醒...
  • 进程同步的5机制

    万次阅读 2018-08-24 09:04:04
    (1)信号量机制 ... 调用者申请的资源如果被占用,即自旋锁被已经被别的执行单元保持,则调用者一直循环在那里看是否该自旋锁的保持着已经释放了锁,自旋锁是一种比较低级的保护数据结构和代码片段的原...
  • 用flock在写文件前先锁上,等写完后解锁,这样就实现了多线程同时读写一个文件避免冲突。大概就是下面这个流程 /* *flock(file,lock,block) *file 必需,规定要锁定或释放的已打开的文件 *lock 必需。
  • 多线程下关于硬件资源释放问题

    千次阅读 2012-07-12 15:00:48
    因为各种硬件资源不像文本资源一样,能够很快的进行释放,这样我们在进行多线程编程时就有可能产生,一个子线程中调用了摄像头,但是在结束的时候,主线程已经结束了,而子线程还未结束,结果导致由于子线程无法退出...
  • 如果所申请的资源被其他等待进程占有,那么该等待进程有可能永远处于等待状态而无法改变该状态。——这种情况即为死锁。  或许你认为进程死锁就死锁呗,那又能怎么样?那么先说出它的危害吧!  当出现死锁时...
  • 为什么空循环进程导致CPU占有率很高?

    万次阅读 多人点赞 2016-01-29 19:57:13
    linux系统是时间片调度算法,微观上所有可运行进程都是串行,不管进程中作何操作,该进程的时间片一到就切换到下一进程,那为什么一个空循环进程CPU占用率还这么高
  • 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.&nbsp; 线程是进程一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本...
  • 1.用堆和栈分配一个变量可能在以后的执行中产生意想不到的结果,而这个结果的表现就是内存的非法被访问,导致内存的内容被修改。 理解这个现象的两个基本概念是:在一个进程的线程共享堆区,而进程中的线程各自维护...
  • 僵尸进程zombie与孤儿进程orphan

    千次阅读 2015-12-10 23:41:47
    问题提出 以前在学习《unix环境高级编程》进程时候,提到孤儿进程和僵尸进程,但是一直对这两概念比较模糊。于是今天做了一些测试程序,并把这些记录下来. 僵尸进程/僵死进程 In UNIX System terminology, a ...
  • 下面有个特性叫 OOM killer ( Out Of Memory killer ) ,这东西会在系统内存耗尽 的情况下跳出来, 选择性的干掉一些进程以求释放一些内存。 典型的情况是: 某天机器突然 登不上了能 ping 通,...
  • 【Linux】Linux进程的创建与管理

    万次阅读 多人点赞 2018-07-27 19:21:29
    在Linux系统中,除了系统启动之后的第一个进程由系统来创建,其余的进程都必须由已存在的进程来创建,新创建的进程叫做子进程,而创建子进程进程叫做父进程。那个在系统启动及完成初始化之后,Linux自动创建的进程...
  • 返回值:子进程中返回0,父进程中返回子进程ID,出错返回-1函数说明:一个现有进程可以调用fork函数创建一个进程。由fork创建的新进程被称为子进程(child process)。fork函数被调用一次但返回两次。两次返回的...
  • 一个系统运行着很多进程,可以比喻为一条马路上很多马车 不同的进程可以理解为不同的马车 而同一辆马车可以很多匹马来拉--这些马就是线程 假设道路的宽度恰好可以通过一辆马车 道路可以认为是临界资源 那么...
  • Oracle 后台进程详解

    万次阅读 2016-04-29 14:27:00
    后台进程后台进程负责保证数据库的稳定工作,每当数据库启动时,这些后台进程会自动启动,并且持续整 个实例的生命周期,每个进程负责一个独特的任务,表2-4 是一些最重要的后台进程。进 程缩 写描 述Database ...
  • 今天又重新复习了一下进程...这些创建子进程的函数本质上都完成了相同的功能——调用进程复制份,得到子进程。(可以通过选项参数来决定各种资源是共享、还是私有。)那么既然调用进程处于TASK_RUNNING状态(否则
  • Linux 进程调度浅析

    千次阅读 2015-04-09 20:30:19
    人说,进程调度是操作系统中最为重要的一个部分。我觉得这种说法说得太绝对了一点,就像很多人动辄就说“某某函数比某某函数效率高XX倍”一样,脱离了实际环境,这些结论是比较片面的。  而进程调度究竟多...
  • linux内核--进程调度(

    千次阅读 2013-09-29 15:20:01
    这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。   进程调度的具体功能可总结为如下几点:   作为进程调度的准备,进程管理模块必须系统中各进程的执行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,622
精华内容 56,248
关键字:

一个进程释放一种资源将有可能导致