精华内容
下载资源
问答
  • 优先级按上面的顺序由高到低, 数字越小优先级越高

    优先级按上面的顺序由高到低, 数字越小优先级越高

     

    展开全文
  • 打印任务分为九个优先级,分别采用数字1~9表示,数字越大优先级越高。 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章...

    某个打印机根据打印队列执行打印任务。打印任务分为九个优先级,分别采用数字1~9表示,数字越大优先级越高。打印机每次从队列头部取出第一个任务A,然后检查队列余下任务中有没有比A优先级更高的任务,如果有比A优先级高的任务,则将任务A放到队列尾部,否则执行任务A的打印。请编写一个程序,根据输入的打印队列,输出实际打印顺序。

    实现了一个,虽然这个实现效率很低,但是是按题目要求来的

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    /*struct pr_node{
    	int pri;
    	struct prnode *next;
    };*/
    
    #define DBG ;//printf("[%s][%d]\n",__func__,__LINE__)
    #define DEBUG(format, ...) ;//printf(format, ##__VA_ARGS__)
    
    typedef struct pr_node{
    	int pri;
    	struct pr_node *next;
    } pnode;
    
    typedef pnode* linkList;
    
    static int printList(linkList* L) {
        linkList p;
        int i = 0;
        p = (*L)->next;
        //printf("print link list\n");
        if (p==NULL) {
             //printf("empty link list\n");
    	return 0;
        }
        DBG;
        do {
            i++;
            //printf("i = %d pri=%d\n",i,p->pri);
            p = p->next;
            //DEBUG("0x%x\n",p->next);
        }
        while (p != NULL);
            //printf("print link list\n");
    
        return 1;
    }
    
    int main(int argc, char** argv)
    {
    	int i = 0;
    	int pri = 0;
    	printf("please printf the sequece of priority, e.g. ./print_order 2 5 8 7 9 0 1 \n");
    
    	linkList L;
    	L = (pnode *)malloc(sizeof(pnode));
    	if (L == NULL)
    		printf("malloc failed\n");
    	L->next = NULL;
    	DBG;
    	for(i = argc-1; i > 0; i--)
    	{
    		DBG;
    		
    		pnode *p;
    		p = (pnode *)malloc(sizeof(pnode));
    		memset(p, 0, sizeof(pnode));
    		DBG;
    		//printf("%s\n",argv[i]);
    		p->pri = atoi(argv[i]);
    		DBG;
    		p->next = L->next;
    		L->next = p;
    	}
    
    	printList(&L);
    	//printf("12\n");
    	i = argc-1;
    	while(i > 0)
    	{
    		pnode *p1 = L->next;
    		pnode *pt = p1->next;
    		//pnode *pe1 = NULL;
    		while(pt != NULL)
    		{
    			p1 = L->next;
    			//printf("%d %d\n",p1->pri, pt->pri);
    			if(p1->pri < pt->pri)
    			{
    				while(pt->next != NULL)
    				{
    					pt = pt->next;
    				}
    				pt->next = p1;
    				L->next = p1->next;
    				p1->next = NULL;
    				pt = L->next->next;
    				printList(&L);
    				continue;
    			}
    			else
    			pt = pt->next;
    		}
    		if(pt == NULL)
    		{
    			printf("pri = %d\n", p1->pri);
    			L->next = p1->next;
    			free(p1);
    			p1 = L->next;
    			i--;
    		}
    		DBG;
    		printList(&L);
    	}
    
    	return 0;	
    }
    				
    
    
    展开全文
  • 线程的优先级:1-10,越大优先级越高优先级越高被OS选中的可能性就越大。(不建议使用,因为不同操作系统的优先级并不相同,使得程序不具备跨平台性,这种优先级只是粗略地划分)。 注:程序的跨平台性:除了...

    进程的休眠:Thread sleep(1000);//括号中以毫秒为单位

    当main()运行完毕,即使在结束时时间片还没有用完,CPU也放弃此时间片,继续运行其他程序。

    Try{Thread.sleep(1000);}

    Catch(Exception e){e.printStackTrace(e);}

    T1.join()表示运行线程放弃执行权,进入阻塞状态。

    当t1结束时,main()可以重新进入运行状态。

    T1.join实际上是把并发的线程编程并行运行。

    线程的优先级:1-10,越大优先级越高,优先级越高被OS选中的可能性就越大。(不建议使用,因为不同操作系统的优先级并不相同,使得程序不具备跨平台性,这种优先级只是粗略地划分)。

    注:程序的跨平台性:除了能够运行,还必须保证运行的结果。

     

     1 package TomTexts;
     2 import java.io.*;
     3 import java.util.Date;
     4 
     5 public class TomTexts_36 {
     6     public static void main(String []args)
     7     {
     8     String filename="d:\\javapj\\ex.java";
     9     File myfile=new File(filename);
    10     if(!myfile.exists() ) 
    11     {   
    12     System.err.println(filename+"未找到!");
    13                     return;  
    14                 }
    15     if( myfile.isDirectory() ) 
    16     { 
    17     System.err.println("文件对象"+myfile.getName()+"是目录!");
    18                   File ds=new File("mydata");
    19                   if(!ds.exists()) 
    20     {
    21                       ds.mkdir();
    22                       System.out.println("目录"+ds.getAbsolutePath()+"创建结束!");
    23                    }
    24                      return;
    25                  }
    26     if(myfile.isFile())
    27     {
    28                   System.out.println("文件对象:"+myfile.getAbsolutePath());
    29                   System.out.println("文件字节数:"+myfile.length());
    30                   System.out.println("文件是否能读:"+myfile.canRead());
    31                   if(myfile.canWrite())
    32                   {
    33                        System.out.println("设置文件为只读:"+myfile.setReadOnly());
    34                   }
    35                   System.out.println("文件是否可写:"+myfile.canWrite());
    36                   Date fd=new Date(myfile.lastModified());
    37                   System.out.println("文件上次修改时间:"+fd.toString());
    38                }
    39              }
    40 
    41 }

     

    转载于:https://www.cnblogs.com/borter/p/9425122.html

    展开全文
  • linux 实时线程优先级问题——数值越大优先级越高吗?  2012-06-03 15:14:23| 分类: linux内核开发 |字号 订阅  今天查看了linux下的实时线程,FIFO和RR策略的调度,遇到一个问题:  ...

    linux 实时线程优先级问题——数值越大优先级越高吗?  

    2012-06-03 15:14:23|  分类: linux内核开发 |字号 订阅

         今天查看了linux下的实时线程,FIFO和RR策略的调度,遇到一个问题:

         priority越大优先级越高呢?还是越小越高呢?

         回答这个问题要明白一个问题,首先,linux2.6内核将任务优先级进行了一个划分:

        0——99  实时进程 

       100——139   非实时进程

        现在,这个划分是起决定作用的,而且一定是数值越小,优先级越高。

        但是,有时候从网上会看到 优先级数值越大,优先级越高?这又是怎么回事?难道有一种说法错了吗?

       实际的原因是这样的,对于一个实时进程,他有两个参数来表明优先级——prio 和 rt_priority,

       prio才是调度所用的最终优先级数值,这个值越小,优先级越高;

       而rt_priority 被称作实时进程优先级,他要经过转化——prio=MAX_RT_PRIO - 1- p->rt_priority; 

       MAX_RT_PRIO = 99;这样意味着rt_priority值越大,优先级越高;

       而内核提供的修改优先级的函数,是修改rt_priority的值,所以越大,优先级越高

       所以用户在使用实时进程或线程,在修改优先级时,就会有“优先级值越大,优先级越高的说法”,也是对的。


    http://bbs.chinaunix.net/thread-1996337-1-1.html
                    关于进程时间片的计算
        进程的时间片time_slice是基于进程静态优先级的。
        静态优先级越高(值越小),时间片就越大。
        计算时间片是通过函数task_timeslice()(kernel/sched.c)来完成的。
        通过优先级来计算时间片的等式为:
            timeslice=MIN_TIMESLICE+((MAX_TIMESLICE-MIN_TIMESLICE)*(MAX_PRIO-1-(p)->static_prio)/(MAX_USER_PRIO-1))
        这样的话就可以将100~139 的优先级映射到200ms~10ms 的时间片上去,优先级数值越大,则分配的时间片越小。
    在Kernel2.6中时间片的计算是分散的,具体的计算既可以用task_timeslice(),也可以用其他方法。
        进程创建时,将父进程的时间片分一半给子进程,同时父进程的时间片减半。
        进程用完时间片以后,需要重新计算时间片,并将进程插入到相应的运行队列。
        进程退出时,根据first_timeslice的值来决定是否将子进程的时间片返还给父进程。
    平均等待时间sleep_avg
        平均等待时间sleep_avg既决定了进程优先级,又影响了进程交互程度。
        进程的平均等待时间(以nanosecond 为单位),在0 到NS_MAX_SLEEP_AVG 之间取值,初值为0。
        这个值是动态优先级计算的关键因子,sleep_avg 越大,计算出来的进程优先级也越高(数值越小)。
                  

    展开全文
  • 路由协议及其发现路由的优先级: 路由协议或路由种类 相应路由的优先级 DIRECT 0 OSPF 10 IS-IS 15 STATIC 60 RIP 100 OSPF ASE 150 OSPF NSSA 150 IBGP 256 EBGP ...
  • 即进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数:在进程获得一次CPU后就将其优先数减少1。 “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
  • 此处的基本数据类型就是int型、double型、char型等可以直接使用的数据类型,优先队列对它们的优先级设置一般是数字大的优先级越高,因此队首元素就是优先队列内元素最大的那个(如果char型,则是字典序最大的)。...
  • 优先级

    2019-10-23 16:52:51
    (注意:优先级数字越优先级越高) 2、抢占优先级相同,不涉及到中断嵌套,响应优先级不同,响应优先级高的先响应。(例如:两个中断同时响应,这里就会先执行响应优先级高的那个中断)(注意:优先级数字越,...
  • java线程优先级越高越先执行吗

    千次阅读 2016-04-01 14:13:58
    不是优先级越高,线程就先执行 优先级反映的是线程占用资源的多少,优先级越高,占用的资源越多,性能越好
  • 数字越小优先级越高 priority_queue< int ,vector< int >,less< int > > que2; // 数字越大优先级越高 priority_queue<node> que; // 自定义结构体优先队列优先级 node now1={ 2 , 3 }; node now2 ={ 1 , ...
  • 优先队列(优先级队列、堆)

    千次阅读 2018-12-17 19:56:06
    优先队列,又称为优先级队列、堆。...我们往往以元素值的大小作为优先级来讨论,比如说,数值大的优先级高,则优先队列元素会按一定规则的大小顺序排列,从而使得在队列头部的元素始终保持数值最大...
  • 响应比优先调度算法则是既考虑了作业等待的时间,又考虑了作业运行时间的调度算法,因此既照顾了短作业,又不致使长作业的等待时间过长,从而改善了处理机的调度能力。 算法实现 优先权的变化规律: 优先权= (等.....
  • 1、抢占优先级比子优先级的优先权更高,这意味抢占优先级更高的中断会先执行,而不管子优先级的优先权,数值越低优先级越高。 2、同理,如果抢占优先级相同,那么就会比较子优先级,子优先级更高的中断将会先被执行...
  •  任务ID,优先级值(值越大,优先级越高),开始时间,持续时间。共5组。 输出代表的意思:  任务ID,执行持续时间,即整个任务执行的顺序。 思路:在做这类题目时,在时间轴上先画出优先级高的时间线,再...
  • linux内核printk优先级

    2020-01-15 20:26:00
    标准使用方式: printk(优先级 “fdasdfsdfas\n...linux内核将打印的优先级分为0~7 共8级,值越小优先级越高 优先级阈值: cat /proc/sys/kernel/printk 7 4 1 7 第一个值:优先级阈值 第二个值:默认优先级 调整优先...
  • linux进程优先级分:1. 实时优先级(跟内核有关),范围0-99,数字越...nice是一个优先值,范围-20-19 这个值越,那么对应的进程优先级越高,在top里,PR-NI=20默认启动一个进程,nice是0,也可以在执行这个...
  • STM32 NVIC 抢占优先级和响应优先级

    万次阅读 多人点赞 2016-01-26 19:34:59
    其属性编号越,表明它的优先级别越高。 抢占,是指打断其它中断的属性,即因为具有这个属性,会出现嵌套中断 (在执行中断服务函数 A 的过程中被中断 B 打断,执行完中断服务函数 B 再继续 执行中断服务函数 A)...
  • FreeRtos 任务优先级和中断优先级

    千次阅读 2019-07-01 17:36:19
    中断优先级和任务优先级的区别: 1.简单的说,这两者之间没有...对应STM32F103 F407来说,中断优先级数值越,优先级就越高,而FreeRTOS的任务优先级是,任务优先级数值越 任务优先级越低。 任务优先级配置 ...
  • 进程优先级

    千次阅读 2018-08-09 18:54:08
    先级越高。从0到99的范围专供实时进程使用。 nice值[20, +19]映射到范围100到139,如图2-14所示。 实时进程的优先级总是比普通进程更高。 下面列出了task_struct结构体中与权限相关的几个成员:...
  • 图的遍历算法 图的遍历都可以理解为,将非线性结构转化为半线性结构的过程。经遍历而确定的边类型中,最重要的一类即所谓的树边,它们与所有顶点共同构成了原图的一棵... 早被访问到的定点,其邻居越优先被选用 ...
  • 如果是VxWorks这样的实时系统,那么优先级高表示优先得到响应(这时候它不一定在执行,也可以在睡眠); Linux系统优先级高表示它倾向于IO消耗型,那么它在中断到来时肯定要尽快投入运行,但是相对CPU消耗型来说, ...
  • 中断优先级和任务优先级: 1、中断优先级和任务优先级...FreeRTOS的任务优先级是,任务优先级数值越优先级越低。 中断优先级: 1、NVIC的全称是Nested vectoredinterrupt controller,即嵌套向量中断控...
  • 关于stm32优先级大小的理解

    千次阅读 2017-12-08 15:02:19
     组别优先顺序(第0组优先级最强,第4组优先级最弱):NVIC_PriorityGroup_0>NVIC_PriorityGroup_1>NVIC_PriorityGroup_2>NVIC_PriorityGroup_3>NVIC_PriorityGroup_4 二、抢占优先级和响应优先级执行...
  • STC32 优先级

    2020-04-09 10:28:48
    1、stc32的分组寄存器只运用了高四位来控制分组,低四位保留。...每一组中优先级越高。 3、优先级初始化代码 NVIC_InitTypeDef NVIC_InitStruct; //定义中断结构体变量 NVIC_InitStruct.NVIC_IRQCh...
  • 算法思想:在按进程达到时间由到大的顺序输入进程信息后,先对其优先数进行排列,将最先到达的进程的到达时间设为开始时间,计算结束时间,然后对后面到达的时间与该进程的结束时间进行比较,如若小于该进程的结束...
  • /*1443. Printer Queue(用一个数组模拟... 优先级,数字越大优先级越高。同时给出一个指定 作业位置下标。 在队列中,优先打印高优先级的作业,若高优先级 在队列头则出队即可,若否,则队列头放到最后,同 时高
  • 请注意优先级值低意味着优先级高。请编辑程序模拟消息队列,将消息加到队列中以及从队列中获取消息。 输入格式: 输入首先给出正整数N(≤10​5​​),随后N行,每行给出一个指令——GET 或PUT,分别表示从队列中取出...
  • 中断优先级

    千次阅读 2017-03-21 19:49:33
    1 的时候,这一位的优先级就比其它位的优先级高了。比如我们设置了 PT0位为 1 后,当单片机在主循环或者任何其它中断程序中执行时,一旦定时器 T0 发生中断,作为更优先级,程序马上就会跑到
  • 进程的优先级

    2015-08-04 22:08:17
    static_prio取值越低优先级越高,越早被调度。内核调度程序根据静态优先级来调度进程执行,这种情况下会导致一些进程优先级低的进程始终得不到CPU资源。这样就难以避免饥饿情况发生,这是不公平的调度。抛出问题,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,906
精华内容 15,962
关键字:

优先数越小优先级越高