精华内容
下载资源
问答
  • 文章目录一、进程的描述与控制1.1 进程1.2 进程的特点1.3 进程的结构二、进程的状态2.1 进程并发执行2.2 进程的2状态2.3 进程的5状态2.4 进程的状态转换图 一、进程的描述与控制 1.1 进程 进程也称之为任务。 指...

    一、进程的描述与控制

    1.1 进程

    • 进程也称之为任务。
    • 指一个程序执行的过程:进程是程序在一个数据集合上的运行过程,是系统进行资源分配调度的一个独立单位;也是可并发执行的程序在一个数据集合上的运行过程
    • 进程是可被跟踪的:可以使用执行指令的序列来进行跟踪。(从处理器角度上)

    1.2 进程的特点

    • 动态性
    • 并发的
    • 独立性
    • 异步性

    1.3 进程的结构

    • 程序(依赖于程序)
    • 数据
    • PCB(Process Control Block)进程控制块

    二、进程的状态

    2.1 进程的并发执行

    例:假设内存中由3个进程A,B 和 C,他们的程序代码已全部装入内存。若A,C两进程需要执行12条指令,B进程需要执行4条指令,且B进程执行到第4条指令处必须等待I/O。如何跟踪他们的执行过程?

    2.2 进程的2状态

    2.2.1 进程可以被理解为两个状态

    • Running(执行):
    • Not-running (非执行):

    2.2.2 状态转换图

    在这里插入图片描述

    • 并非所有进程只要Not-Runing就处于ready状态(就绪:完事具备,就差CPU分配给我),有的需要blocking(阻塞)等待I/O完成。
    • Not-running又可分为ready和blocked两种状态。
      所以2状态比较难处理这类情况。

    2.3 进程的5状态

    2.3.1 进程可被分为5个状态

    • Running(执行):占用处理器(单处理机环境中,某一时刻仅一个进程占用处理机)
    • Ready(就绪):准备执行的状态,准备被调度的状态,有机会就会开始执行。
    • Blocked(阻塞):等待某事件发生才能执行,如 等待I\O完成等。
    • New(新状态):进程控制块(PCB)已经创建,但未被OS接纳为可执行进程。
    • Exit(退出):因停止或取消,被OS从执行状态释放(将死状态)。

    2.3.2 状态转换图

    在这里插入图片描述

    • Null -> New:新创建进程首先处于新状态。
    • new -> Ready:OS接纳新状态进程为就绪进程。
    • Ready -> Running:OS只能从就绪进程中选一个进程执行。
    • Running -> Exit:执行状态的进程执行完毕,或被取消,则转换为退出状态。
    • Running -> Ready:分时系统中,时间片用完,或者优先级高的进程到来,及那个种植优先级低的进程的执行。
    • Running -> Block:执行进程需要等待某事件发生。通常因进程需要的系统调用不能立即完成,而阻塞(非锁死)。
    • Block -> Ready:当阻塞进程等待的事件发生,就转换为就绪状态。
    • Ready -> Exit:某些系统允许父进程在任何情况下终止其子进程。若一个父进程终止,其子孙进程都必须终止。
    • Block -> Exit:同上。

    进程在运行过程当中,等待的事件可能不相同,所以我们可能需要不同类型的阻塞队列。

    展开全文
  • 程序的并发执行

    千次阅读 2018-09-09 21:23:31
    在早期无操作系统及单道批处理系统时,程序是按照顺序进行执行的。先进入内存的先执行,在执行的过程中不能执行其他的程序。程序中的指令也是按照顺序执行,一条指令正在执行时不能开始执行另一条指令。所以程序...

    一、程序的顺序执行

    在早期无操作系统及单道批处理系统时,程序都是按照顺序进行执行的。先进入内存的先执行,在执行的过程中不能执行其他的程序。程序中的指令也是按照顺序执行,一条指令正在执行时不能开始执行另一条指令。所以程序顺序执行有以下几个特点。

    1.1、顺序性

    处理机的操作,严格按照顺序执行,前一操作还没执行完毕,后继操作则不能继续执行。

    1.2、封闭性

    程序是在封闭的环境下运行的。即程序在运行时独占全机资源,各资源的状态只有本程序才能改变。程序一旦开始运行,其结果不受外界的影响。

    1.3、可再现性

    只要程序的环境和初始条件相同,无论程序执行多少次,执行结果相同。例如一个加法运算,无论执行多少次,相加的结果都不会发生改变。

    二、程序的并发执行

    程序的并发执行是指在同一时间间隔内运行多个程序。也就是在一个程序运行结束之前,可以运行其它的程序。对于用户来说,有多个程序在同时向前推进,但是从微观上来看,任意时刻CPU上都只有一个程序在执行。在多道程序系统和分时系统都允许程序并发执行,程序的并发执行有以下几个特点。

    2.1、间断性

    程序在并发执行时,因为要共享资源,但是资源往往都少于正在执行的程序数,所以会存在资源抢占的问题。因而,每个程序在CPU上运行,都是时断时续的。当一个资源被占用时,其他需要该资源的程序不得不暂停,待资源被释放时方可执行。

    2.2、失去封闭性

    程序正在并发执行时,由于它们共享资源或者合作完成同一项任务,系统的状态不再受其中一个程序的控制和改变,所以就失去了封闭性。比如淘宝卖商品,每卖出一件库存都要减去1,而进货又可以对库存进行增加,所以库存已经不是某个程序特有的了。伪代码如下:

    <?php
        //卖出商品
        sentProduct('商品1');
        $stock--;   //库存减一
    
        //进货
        purchase('商品1');
        $stock += 10;   //库存加10
    ?>

    2.3、不可再现性

    因为程序在并发执行时失去了封闭性,所以任何一个程序都有可能对系统的状态进行改变,这也意味着程序执行的结果可能会不相同。例如两个程序同时往一个文件追加内容,在执行数次之后,每个文件所展现出的内容可能各不相同。

    <?php
        //程序a往文件追加1
        for ($i = 0; $i < 5; $i++) {
            file_put_contents('/tmp/test.txt', 1, FILE_APPEND);
        }
    
        //程序b往文件追加2
        for ($i = 0; $i < 5; $i++) {
            file_put_contents('/tmp/test.txt', 2, FILE_APPEND);
        }
    ?>

    同时执行两次的结果:

    1212121212  //结果1
    1122122121  //结果2
    展开全文
  • Linux Shell实现多进程并发执行

    万次阅读 2017-08-18 10:16:58
    在不加控制的模式下,不管有多少任务,全部后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况: 实例一:正常情况脚本 ——————————————————...

    在bash中,使用后台任务来实现任务的“多进程化”。在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况:

    实例一:正常情况脚本

    ———————————————————————————–

    #!/bin/bash

    for ((i=0;i<5;i++));do

    {

    sleep 1;echo 1>>aa && echo ”done!”

    }

    done

    cat aa|wc -l

    rm aa

    ———————————————————————————–

    这种情况下,程序顺序执行,每个循环3s,共需15s左右。

    $ time bash test.sh

    done!

    done!

    done!

    done!

    done!

    5

    real    0m15.030s

    user    0m0.002s

    sys     0m0.003s

    实例二:“多进程”实现

    ———————————————————————————–

    #!/bin/bash

    for ((i=0;i<5;i++));do

    {

    sleep 3;echo 1>>aa && echo ”done!”

    } &

    done

    wait

    cat aa|wc -l

    rm aa

    ———————————————————————————–

    这个实例实际上就在上面基础上多加了一个后台执行&符号,此时应该是5个循环任务并发执行,最后需要3s左右时间。

    $ time bash test.sh

    done!

    done!

    done!

    done!

    done!

    5

    real    0m3.011s

    user    0m0.002s

    sys     0m0.004s

    效果非常明显。

    这里需要说明一下wait的左右。wait是等待前面的后台任务全部完成才往下执行,否则程序本身是不会等待的,这样对后面依赖前面任务结果的命令来说就可能出错。例如上面wc 

    -l的命令就报错:不存在aa这个文件。

    以上所讲的实例都是进程数目不可控制的情况,下面描述如何准确控制并发的进程数目。

    ——————————————————————————————————————

    #!/bin/bash

    # 2006-7-12, by wwy

    #———————————————————————————–

    # 此例子说明了一种用wait、read命令模拟多线程的一种技巧

    # 此技巧往往用于多主机检查,比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况

    # 还说明了多线程的控制

    #———————————————————————————–

    function a_sub { # 此处定义一个函数,作为一个线程(子进程)

    sleep 3 # 线程的作用是sleep 3s

    }

    tmp_fifofile=”/tmp/$.fifo”

    mkfifo $tmp_fifofile      # 新建一个fifo类型的文件

    exec 6<>$tmp_fifofile      # 将fd6指向fifo类型

    rm $tmp_fifofile

    thread=15 # 此处定义线程数

    for ((i=0;i<$thread;i++));do

    echo

    done >&6 # 事实上就是在fd6中放置了$thread个回车符

    for ((i=0;i<50;i++));do # 50次循环,可以理解为50个主机,或其他

    read -u6

    # 一个read -u6命令执行一次,就从fd6中减去一个回车符,然后向下执行,

    # fd6中没有回车符的时候,就停在这了,从而实现了线程数量控制

    { # 此处子进程开始执行,被放到后台

    a_sub && { # 此处可以用来判断子进程的逻辑

    echo ”a_sub is finished”

    } || {

    echo ”sub error”

    }

    echo >&6 # 当进程结束以后,再向fd6中加上一个回车符,即补上了read -u6减去的那个

    } &

    done

    wait # 等待所有的后台子进程结束

    exec 6>&- # 关闭df6

    exit 0

    ——————————————————————————————————————

    sleep 3s,线程数为15,一共循环50次,所以,此脚本一共的执行时间大约为12秒

    即:

    15×3=45, 所以 3 x 3s = 9s

    (50-45=5)<15, 所以 1 x 3s = 3s

    所以 9s + 

    3s = 12s

    $ time ./multithread.sh >/dev/null

    real        0m12.025s

    user        0m0.020s

    sys         0m0.064s

    而当不使用多线程技巧的时候,执行时间为:50 x 3s = 150s。

    此程序中的命令 mkfifo tmpfile和linux中的命令 mknod tmpfile p效果相同。

    区别是mkfifo为POSIX标准,因此推荐使用它。该命令创建了一个先入先出的管道文件,并为其分配文件标志符6。管道文件是进程之间通信的一种方式,注意这一句很重要

    exec 6<>$tmp_fifofile      # 将fd6指向fifo类型

    如果没有这句,在向文件$tmp_fifofile或者&6写入数据时,程序会被阻塞,直到有read读出了管道文件中的数据为止。而执行了上面这一句后就可以在程序运行期间不断向fifo类型的文件写入数据而不会阻塞,并且数据会被保存下来以供read程序读出



    ******************************************************************************

    http://bbs.51cto.com/thread-1104907-1-1.html

    根据我个人的理解, 所谓的多进程 只不过是将多个任务放到后台执行而已,很多人都用到过,所以现在讲的主要是控制,而不是实现。
    先看一个小shell:
     

    看执行结果:
     

    很明显是8s
    =============================
    这种不占处理器却有很耗时的进程,我们可以通过一种后台运行的方式
    来达到节约时间的目的。看如下改进:

     

    用“{}”将主执行程序变为一个块,用&放入后台,四次执行全部放入后台后,我们
    需要用一个wait指令,等待所有后台进程执行结束,
    不然 系统是不会等待的,直接继续执行后续指令,知道整个程序结束。
    看结果:

     

    可以看到,时间已经大大缩短了!

    ============================
    以上实验虽然达到了多线程并发的目的,但有一个缺陷,不能控制
    运行在后台的进程数。
    为了控制进程,我们引入了管道 和文件操作符
    无名管道: 就是我们经常使用的 例如: cat text | grep "abc" 
                       那个“|”就是管道,只不过是无名的,可以直接作为两个进程的数据通道
    有名管道: mkfilo  可以创建一个管道文件 ,例如: mkfifo fifo_file

    管道有一个特点,如果管道中没有数据,那么取管道数据的操作就会停滞,直到
    管道内进入数据,然后读出后才会终止这一操作,同理,写入管道的操作
    如果没有读取操作,这一个动作也会停滞。

     

    当我们试图用echo想管道文件中写入数据时,由于没有任何进程在对它做读取操作,所以
    它会一直停留在那里等待读取操作,此时我们在另一终端上用cat指令做读取操作

     

    你会发现读取操作一旦执行,写入操作就可以顺利完成了,同理,先做读取操作也是一样的:
     


    由于没有管道内没有数据,所以读取操作一直滞留在那里等待写入的数据
     

    一旦有了写入的数据,读取操作立刻顺利完成

    以上实验,看以看到,仅仅一个管道文件似乎很难实现 我们的目的(控制后台线程数),
    所以 接下来介绍 文件操作符,这里只做简单的介绍,如果不熟悉的可以自行查阅资料。
    系统运行起始,就相应设备自动绑定到了 三个文件操作符   分别为 0 1 2 对应 stdin ,stdout, stderr 。
    在  /proc/self/fd 中 可以看到 这三个三个对应文件

     

    输出到这三个文件的内容都会显示出来。只是因为显示器作为最常用的输出设备而被绑定。

    我们可以exec 指令自行定义、绑定文件操作符
    文件操作符一般从3-(n-1)都可以随便使用
    此处的n 为 ulimit -n 的定义值得
     



    可以看到 我的 n值为1024 ,所以文件操作符只能使用 0-1023,可自行定义的 就只能是 3-1023 了。

    直接上代码,然后根据代码分析每行代码的含义:
     


    第3行:         接受信号 2 (ctrl +C)做的操作
                          exec 1000>&-和exec 1000<&- 是关闭fd1000的意思
                          我们生成做绑定时 可以用 exec 1000<>testfifo 来实现,但关闭时必须分开来写
                          > 读的绑定,< 标识写的绑定  <> 则标识 对文件描述符 1000的所有操作等同于对管道文件
                          testfifo的操作。

    第5-7行:     分别为 创建管道文件,文件操作符绑定,删除管道文件
              可能会有疑问,为什么不能直接使用管道文件呢? 
              事实上,这并非多此一举,刚才已经说明了管道文件的一个重要特性了,那就是读写必须同时存在
              缺少某一种操作,另一种操作就是滞留,而绑定文件操作符 正好解决了这个问题。
               (至于为什么,我还没研究明白,有知道的 还请告知,谢谢)

    第9-12 行:    对文件操作符进行写入操作。 通过一个for循环写入10个空行,这个10就是我们要定义的后台线程数量。
                          为什么写入空行而不是10个字符呢 ?
                           这是因为,管道文件的读取 是以行为单位的。
     


      当我们试图用 read 读取管道中的一个字符时,结果是不成功的,而刚才我们已经证实使用cat是可以读取的。

    第17-24行:  这里假定我们有100个任务,我们要实现的时 ,保证后台只有10个进程在同步运行 。
                         read -u1000 的作用是:读取一次管道中的一行,在这儿就是读取一个空行。
                         减少操作附中的一个空行之后,执行一次任务(当然是放到后台执行),需要注意的是,这个任务在后台执行结束以后
                         会向文件操作符中写入一个空行,这就是重点所在,如果我们不在某种情况某种时刻向操作符中写入空行,那么结果就是:
                         在后台放入10个任务之后,由于操作符中没有可读取的空行,导致  read -u1000 这儿 始终停顿。

    后边的 就不用解释了,贴下执行结果:


     


    每次的停顿中都能看到  只有10个进程在运行
    一共耗时50s  
    一共100个任务,每次10个 ,每个5s 正好50s

    上边的结果图之所以这么有规律,这是因为我们所执行的100个任务耗时都是相同的,
    比如,系统将第一批10个任务放入后台的过程所消耗的时间 几乎可以忽略不计,也就是说
    这10个任务几乎可以任务是同时运行,当然也就可以认为是同时结束了,而按照刚才的分析,
    一个任务结束时就会向文件描述符写入空行,既然是同时结束的,那么肯定是同时写入的空行,
    所以下一批任务又几乎同时运行,如此循环下去的。
    实际应用时,肯定不是这个样子的,比如,第一个放到后台执行的任务,是最耗时间的,
    那他肯定就会是最后一个执行完毕。
    所以,实际上来说,只要有一个任务完成,那么下一个任务就可以被放到后台并发执行了。

    展开全文
  • Linux shell实现多进程并发执行

    千次阅读 2019-08-15 11:57:10
    在不加控制的模式下,不管有多少任务,全部后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况: 实例一:正常情况脚本 ————————————————————...

    二次转载自 https://blog.csdn.net/hellojoy/article/details/77340238

    在bash中,使用后台任务来实现任务的“多进程化”。在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况:

    实例一:正常情况脚本

    ———————————————————————————–

    #!/bin/bash
    
    for ((i=0;i<5;i++));do
    
    {
    
    sleep 1;echo 1>>aa && echo ”done!”
    
    }
    
    done
    
    cat aa|wc -l
    
    rm aa
    
    ———————————————————————————–
    

    这种情况下,程序顺序执行,每个循环3s,共需15s左右。

    $ time bash test.sh
    
    done!
    
    done!
    
    done!
    
    done!
    
    done!
    
    5
    
    real    0m15.030s
    
    user    0m0.002s
    
    sys     0m0.003s
    
    

    实例二:“多进程”实现

    ———————————————————————————–

    #!/bin/bash
    
    for ((i=0;i<5;i++));do
    
    {
    
    sleep 3;echo 1>>aa && echo ”done!”
    
    } &
    
    done
    
    wait
    
    cat aa|wc -l
    
    rm aa
    
    ———————————————————————————–
    

    这个实例实际上就在上面基础上多加了一个后台执行&符号,此时应该是5个循环任务并发执行,最后需要3s左右时间。

    $ time bash test.sh
    
    done!
    
    done!
    
    done!
    
    done!
    
    done!
    
    5
    
    real    0m3.011s
    
    user    0m0.002s
    
    sys     0m0.004s
    
    

    效果非常明显。

    这里需要说明一下wait的左右。wait是等待前面的后台任务全部完成才往下执行,否则程序本身是不会等待的,这样对后面依赖前面任务结果的命令来说就可能出错。
    例如上面wc -l的命令就报错:不存在aa这个文件。

    以上所讲的实例都是进程数目不可控制的情况,

    下面描述如何准确控制并发的进程数目。

    ——————————————————————————————————————

    #!/bin/bash
    
    # 2006-7-12, by wwy
    
    #———————————————————————————–
    
    # 此例子说明了一种用wait、read命令模拟多线程的一种技巧
    
    # 此技巧往往用于多主机检查,比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况
    
    # 还说明了多线程的控制
    
    #———————————————————————————–
    
    function a_sub { # 此处定义一个函数,作为一个线程(子进程)
    
    sleep 3 # 线程的作用是sleep 3s
    
    }
    
    tmp_fifofile=”/tmp/$.fifo”
    
    mkfifo $tmp_fifofile      # 新建一个fifo类型的文件
    
    exec 6<>$tmp_fifofile      # 将fd6指向fifo类型
    
    rm $tmp_fifofile
    
    thread=15 # 此处定义线程数
    
    for ((i=0;i<$thread;i++));do
    
    echo
    
    done >&6 # 事实上就是在fd6中放置了$thread个回车符
    
    for ((i=0;i<50;i++));do # 50次循环,可以理解为50个主机,或其他
    
    read -u6
    
    # 一个read -u6命令执行一次,就从fd6中减去一个回车符,然后向下执行,
    
    # fd6中没有回车符的时候,就停在这了,从而实现了线程数量控制
    
    { # 此处子进程开始执行,被放到后台
    
    a_sub && { # 此处可以用来判断子进程的逻辑
    
    echo ”a_sub is finished”
    
    } || {
    
    echo ”sub error”
    
    }
    
    echo >&6 # 当进程结束以后,再向fd6中加上一个回车符,即补上了read -u6减去的那个
    
    } &
    
    done
    
    wait # 等待所有的后台子进程结束
    
    exec 6>&- # 关闭df6
    
    exit 0
    
    ——————————————————————————————————————
    

    sleep 3s,线程数为15,一共循环50次,所以,此脚本一共的执行时间大约为12秒

    即:

    15×3=45, 所以 3 x 3s = 9s

    (50-45=5)<15, 所以 1 x 3s = 3s

    所以 9s + 3s = 12s

    $ time ./multithread.sh >/dev/null
    
    real        0m12.025s
    
    user        0m0.020s
    
    sys         0m0.064s
    
    

    而当不使用多线程技巧的时候,执行时间为:50 x 3s = 150s。

    此程序中的命令 mkfifo tmpfile和linux中的命令 mknod tmpfile p效果相同。

    区别是mkfifo为POSIX标准,因此推荐使用它。该命令创建了一个先入先出的管道文件,并为其分配文件标志符6。管道文件是进程之间通信的一种方式,注意这一句很重要

    exec 6<>$tmp_fifofile # 将fd6指向fifo类型

    如果没有这句,在向文件$tmp_fifofile或者&6写入数据时,程序会被阻塞,直到有read读出了管道文件中的数据为止。而执行了上面这一句后就可以在程序运行期间不断向fifo类型的文件写入数据而不会阻塞,并且数据会被保存下来以供read程序读出


    http://bbs.51cto.com/thread-1104907-1-1.html

    根据我个人的理解, 所谓的多进程 只不过是将多个任务放到后台执行而已,很多人都用到过,所以现在讲的主要是控制,而不是实现。

    这种不占处理器却有很耗时的进程,我们可以通过一种后台运行的方式
    来达到节约时间的目的。看如下改进:

     zhangji16@zhangji16vm:~/c_study/shell_study$ cat muti_process.sh 
    #!/bin/bash
    
    trap "exec 1000>&-;exec 1000<&-;exit 0" 2
    
    mkfifo testfifo
    exec 1000<>testfifo
    rm -fr testfifo
    
    for ((n=1;n<=10;n++))
    do
        echo >&1000
    done
    
    
    start=`date "+%s"`
    
    for((i=1;i<=100;i++))
    do
        read -u1000
        {
            echo success$i;sleep 5
            echo >&1000
        }&
    done
    
    wait
    
    end=`date "+%s"`
    
    echo "TIME: `expr $end - $start `"
    
    exec 1000>&-
    exec 1000<&-
    

    用“{}”将主执行程序变为一个块,用&放入后台,四次执行全部放入后台后,我们
    需要用一个wait指令,等待所有后台进程执行结束,
    不然 系统是不会等待的,直接继续执行后续指令,知道整个程序结束。
    看结果:

    可以看到,时间已经大大缩短了!

    ============================
    以上实验虽然达到了多线程并发的目的,但有一个缺陷,不能控制
    运行在后台的进程数。
    为了控制进程,我们引入了管道 和文件操作符。
    无名管道: 就是我们经常使用的 例如: cat text | grep “abc”
    那个“|”就是管道,只不过是无名的,可以直接作为两个进程的数据通道
    有名管道: mkfilo 可以创建一个管道文件 ,例如: mkfifo fifo_file

    管道有一个特点,如果管道中没有数据,那么取管道数据的操作就会停滞,直到
    管道内进入数据,然后读出后才会终止这一操作,同理,写入管道的操作
    如果没有读取操作,这一个动作也会停滞。

    当我们试图用echo想管道文件中写入数据时,由于没有任何进程在对它做读取操作,所以
    它会一直停留在那里等待读取操作,此时我们在另一终端上用cat指令做读取操作

    你会发现读取操作一旦执行,写入操作就可以顺利完成了,同理,先做读取操作也是一样的:

    由于没有管道内没有数据,所以读取操作一直滞留在那里等待写入的数据

    一旦有了写入的数据,读取操作立刻顺利完成

    以上实验,看以看到,仅仅一个管道文件似乎很难实现 我们的目的(控制后台线程数),
    所以 接下来介绍 文件操作符,这里只做简单的介绍,如果不熟悉的可以自行查阅资料。
    系统运行起始,就相应设备自动绑定到了 三个文件操作符 分别为 0 1 2 对应 stdin ,stdout, stderr 。
    在 /proc/self/fd 中 可以看到 这三个三个对应文件

    输出到这三个文件的内容都会显示出来。只是因为显示器作为最常用的输出设备而被绑定。

    我们可以exec 指令自行定义、绑定文件操作符
    文件操作符一般从3-(n-1)都可以随便使用
    此处的n 为 ulimit -n 的定义值得

    可以看到 我的 n值为1024 ,所以文件操作符只能使用 0-1023,可自行定义的 就只能是 3-1023 了。

    直接上代码,然后根据代码分析每行代码的含义:

    第3行: 接受信号 2 (ctrl +C)做的操作
    exec 1000>&-和exec 1000<&- 是关闭fd1000的意思
    我们生成做绑定时 可以用 exec 1000<>testfifo 来实现,但关闭时必须分开来写
    > 读的绑定,< 标识写的绑定 <> 则标识 对文件描述符 1000的所有操作等同于对管道文件
    testfifo的操作。

    第5-7行:   分别为 创建管道文件,文件操作符绑定,删除管道文件
           可能会有疑问,为什么不能直接使用管道文件呢? 
          事实上,这并非多此一举,刚才已经说明了管道文件的一个重要特性了,那就是读写必须同时存在
          缺少某一种操作,另一种操作就是滞留,而绑定文件操作符 正好解决了这个问题。
         (至于为什么,我还没研究明白,有知道的 还请告知,谢谢)

    第9-12 行: 对文件操作符进行写入操作。 通过一个for循环写入10个空行,这个10就是我们要定义的后台线程数量。
    为什么写入空行而不是10个字符呢 ?
    这是因为,管道文件的读取 是以行为单位的。

    当我们试图用 read 读取管道中的一个字符时,结果是不成功的,而刚才我们已经证实使用cat是可以读取的。

    第17-24行: 这里假定我们有100个任务,我们要实现的时 ,保证后台只有10个进程在同步运行 。
    read -u1000 的作用是:读取一次管道中的一行,在这儿就是读取一个空行。
    减少操作附中的一个空行之后,执行一次任务(当然是放到后台执行),需要注意的是,这个任务在后台执行结束以后
    会向文件操作符中写入一个空行,这就是重点所在,如果我们不在某种情况某种时刻向操作符中写入空行,那么结果就是:
    在后台放入10个任务之后,由于操作符中没有可读取的空行,导致 read -u1000 这儿 始终停顿。

    后边的 就不用解释了,贴下执行结果:

    每次的停顿中都能看到 只有10个进程在运行
    一共耗时50s
    一共100个任务,每次10个 ,每个5s 正好50s

    上边的结果图之所以这么有规律,这是因为我们所执行的100个任务耗时都是相同的,
    比如,系统将第一批10个任务放入后台的过程所消耗的时间 几乎可以忽略不计,也就是说
    这10个任务几乎可以任务是同时运行,当然也就可以认为是同时结束了,而按照刚才的分析,
    一个任务结束时就会向文件描述符写入空行,既然是同时结束的,那么肯定是同时写入的空行,
    所以下一批任务又几乎同时运行,如此循环下去的。
    实际应用时,肯定不是这个样子的,比如,第一个放到后台执行的任务,是最耗时间的,
    那他肯定就会是最后一个执行完毕。
    所以,实际上来说,只要有一个任务完成,那么下一个任务就可以被放到后台并发执行了。

    展开全文
  • 操作系统之进程并发进程(一)

    千次阅读 多人点赞 2018-11-03 21:55:22
    传统的程序设计方法是顺序程序设计,即把一程序设计成一顺序执行的程序模块,不同程序也是按序执行的。顺序分成内部顺序和外部顺序 内部的顺序性 : 程序在处理器上执行时严格有序的,即只有当一操作结束后,...
  • 请详述操作系统中的线程的基本概念、以及线程的基本状态 什么是进程 进程是指在系统中正在运行的一个应用程序;程序一旦运行就是进程,或者更专业化来说:进程是指程序执行时的一个实例。...一个进程可以...
  • Linux Shell多进程并发以及并发数控制

    千次阅读 2018-06-30 18:22:01
    1. 基础知识准备 1.1. linux后台进程 Unix是一多任务系统,允许多用户同时运行多程序。shell的元字符&...字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一命令了。 比如: ...
  • 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和 体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过 程。掌握进程控制的方法,了解父子进程间的控制和协作...
  • 第三章 并发进程 1.顺序程序设计的特点: 程序执行的顺序性:一程序在处理器上的执行是严格按序的,即每操作必须在下一操作开始之前结束。 程序环境的封闭性:运行程序独占全部资源,除初始状态外,其所处的...
  • 昨天遇到做一笔试题,被自己菜枯了。遇到了这种数据库并发的题,我之前竟然没有见过。。。还是要脚踏实地才能找到好工作啊。 废话不多说,遇到的题目和网上的题目大同小异。所以我就直接用网上的题目了。 首先...
  • 又称间接制约关系,就是计算机的某些临界资源一次只可以被一个进程访问。(举个例子,两个人不能同时用一个马桶…) 下面我们可以一步步正解出答案: A选项,a1、a2均为线程内的临时变量,赋值依旧也不改变最终结
  • python的并发执行(多线程和多进程) 前言 运行代码有的时候就像工厂生产东西,我们程序员可以看成厂长,我们会希望我这厂里多加几条产线,或者多开几厂,从而提高产量或者说提高效率。(写完吐槽:这厂长真苦...
  • 1.n个并发进程通过初值为1的信号量s共享资源R,当n个进程都通过wait(s)申请访问资源R时,信号量s的值为(     )。 编号 选项 A 0 B n C -n D -(n-1) 2.下列哪种方式不支持多...
  • 四、 程序的并发执行

    千次阅读 2020-05-23 16:59:52
    宏观上看是多程序同时执行,微观上看是多程序分时占用CPU。这种程序的运行方式为并发执行。 方法执行时的新特征: 间断性:程序在比并发执行时,...失去封闭性:当系统中存在多个可以并发执行的程序时,系统中..
  • 一:线程与进程 1.概念 线程:是程序执行流的最小单元,是系统独立调度和分配...当一个程序开始运行时,它就是一个进程,进程包括运行中的程序和程序所使用到的内存和系统资源。CPU是以时间片的方式为进程分配CU...
  • 操作系统:程序的并发执行

    千次阅读 2018-09-09 21:22:00
    在早期无操作系统及单道批处理系统时,程序是按照顺序进行执行的。先进入内存的先执行,在执行的过程中不能执行其他的程序。程序中的指令也是按照顺序执行,一条指令正在执行时不能开始执行另一条指令。所以程序...
  • [Linux]Linux Shell多进程并发以及并发数控制

    万次阅读 多人点赞 2016-09-12 12:56:59
    Unix是一多任务系统,允许多用户同时运行多程序。shell的元字符&提供了在后台运行不需要键盘输入的程序的方法...输入命令后,其后紧跟&字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一命令了。
  • CPU、核心,进程、线程,串行、并发、并行
  • 并发相关术语:原子操作:一个...死锁:两个两个以上的进程因其中的每个进程都在等待其他进程做完某件事情而不能执行,这样的情形叫做死锁。活锁:两个两个以上的进程为了响应其他进程的变化持续改变自己的状态...
  • 并发服务器--多进程实现

    千次阅读 2018-03-01 21:58:17
    通过简单的socket可以实现一对一的c/s通信,当多客户端同时进行服务器访问,那么服务器只能按序的一一进行处理,除了第一客户端,其余客户端都会陷入等待。并且这样的程序只能实现半双工通信(数据能双向传输,...
  • 多线程并发执行及解决方法

    千次阅读 2019-02-02 13:10:49
    用一案例来说明:假如我们要实现一售票的小功能,用3线程售出共2000张票。 初始模型为: package com.test7; public class synchronizedTest { public static void main(String [] args){ TicketWindow ...
  • 1. 基础知识准备 1.1. linux后台进程 ...字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一命令了。  比如: sh a.sh &amp; sh b.sh &amp; sh c.sh &amp; 这三命令就...
  • 进程是一具有一定独立功能的程序在一数据集上的一次动态执行的过程,是操作系统进行资源分配和调度的一独立单位,是应用程序运行的载体。进程是一种抽象的概念,从来没有统一的标准定义。进程一般由程序,数据...
  • java并发编程-进程和线程调度基础

    万次阅读 2020-02-20 14:38:54
    操作系统一般是按照一定策略,定期给每个活动的进程执行其内部程序的机会,并且每次只执行一小段时间,然后操作系统利用中断强行退出执行,将当前程序信息压栈,然后开始执行下一个进程的一小段程序。通过这样不断...
  • (程序运行起来之后,产生一个进程)。 那么我们可以形象的将程序比作一个剧本,这个剧本就是一张一张的纸组成的,那么就是进程就要演的戏,一出戏上面包括舞台、演员、灯光、道具等等。同一...
  • 基于Linux的Socket编程之TCP全双工Server-Client聊天程序 一、多进程并发分析:特点: 占用资源大,但是一个进程挂了不会影响另一个。这与多线程刚好相反,多线程服务器不稳定。分析: 父进程循环accept,当父...
  • (同一时间内两个软件同时运行,只有多核cpu多个软件一起运行。任务数小于等于cpu核数,并行执行多任务) python执行多任务的方式:进程、线程、协程 进程:一个正在运行的程序或者软件 启动进程时,...
  • 是指两个两个以上的进程执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁...
  • 线程和进程、并行和并发的概念

    千次阅读 2018-05-09 00:20:53
    并发在微观上不是同时执行的,只是把时间分成若干段,使多个进程快速交替的执行,因为 CPU 计算速度很快,从宏观上看,好像这些进程在同一个时间点执行 并行是真正的细粒度上的同时进行:既同一时间点上同时运行...
  • 1.并发进程 1.1顺序进程并发进程

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 236,892
精华内容 94,756
关键字:

任意两个进程都可以并发执行