精华内容
下载资源
问答
  • 优先级

    2019-04-18 16:37:43
    优先级1 优先级2 优先级3 优先级4 优先级5 优先级6 优先级7 优先级8-13

    优先级1
    在这里插入图片描述
    优先级2
    在这里插入图片描述
    优先级3
    在这里插入图片描述
    优先级4
    在这里插入图片描述
    优先级5
    在这里插入图片描述
    优先级6
    在这里插入图片描述
    优先级7
    在这里插入图片描述
    优先级8-13
    在这里插入图片描述

    展开全文
  • 路由优先级路由优先级路由优先级路由优先级路由优先级路由优先级路由优先级
  • 1、抢占优先级比子优先级的优先权更高,这意味抢占优先级更高的中断会先执行,而不管子优先级的优先权,数值越低优先级越高。 2、同理,如果抢占优先级相同,那么就会比较子优先级,子优先级更高的中断将会先被执行...

    、抢占优先级比子优先级的优先权更高,这意味抢占优先级更高的中断会先执行,而不管子优先级的优先权,数值越低优先级越高。
    、同理,如果抢占优先级相同,那么就会比较子优先级,子优先级更高的中断将会先被执行,数值越低优先级越高。
    、当两个中断源的抢占式优先级相同时,这两个中断将没有嵌套关系,当一个中断到来后,如果正在处理另一个中断,这个后到来的中断就要等到前一个中断处理完之后才能被处理。如果这两个中断同时到达,则中断控制器根据他们的响应优先级高低来决定先处理哪一个;如果他们的抢占式优先级和响应优先级都相等,则根据他们在中断表中的排位顺序决定先处理哪一个。
    、既然每个中断源都需要被指定这两种优先级,就需要有相应的寄存器位记录每个中断的优先级;在Cortex-M3中定义了8个比特位用于设置中断源的优先级,这8个比特位可以有8种分配方式,如下:

    所有8位用于指定响应优先级
    最高1位用于指定抢占式优先级,最低7位用于指定响应优先级
    最高2位用于指定抢占式优先级,最低6位用于指定响应优先级
    最高3位用于指定抢占式优先级,最低5位用于指定响应优先级
    最高4位用于指定抢占式优先级,最低4位用于指定响应优先级
    最高5位用于指定抢占式优先级,最低3位用于指定响应优先级
    最高6位用于指定抢占式优先级,最低2位用于指定响应优先级
    最高7位用于指定抢占式优先级,最低1位用于指定响应优先级

    这就是优先级分组的概念。

    ========================================================================

    、Cortex-M3允许具有较少中断源时使用较少的寄存器位指定中断源的优先级,因此STM32把指定中断优先级的寄存器位减少到4位,这4个寄存器位的分组方式如下:

    第0组:所有4位用于指定响应优先级
    第1组:最高1位用于指定抢占式优先级,最低3位用于指定响应优先级
    第2组:最高2位用于指定抢占式优先级,最低2位用于指定响应优先级
    第3组:最高3位用于指定抢占式优先级,最低1位用于指定响应优先级
    第4组:所有4位用于指定抢占式优先级

    可以通过调用STM32的固件库中的函数NVIC_PriorityGroupConfig()选择使用哪种优先级分组方式,这个函数的参数有下列5种:

    NVIC_PriorityGroup_0 => 选择第0组
    NVIC_PriorityGroup_1 => 选择第1组
    NVIC_PriorityGroup_2 => 选择第2组
    NVIC_PriorityGroup_3 => 选择第3组
    NVIC_PriorityGroup_4 => 选择第4组

    接下来就是指定中断源的优先级,下面以一个简单的例子说明如何指定中断源的抢占式优先级和响应优先级:

    // 选择使用优先级分组第1组
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
      
    // 使能EXTI0中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // 指定抢占式优先级别1
    
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 指定响应优先级别0
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
      
    // 使能EXTI9_5中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 指定抢占式优先级别0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; // 指定响应优先级别1
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    

    ========================================================================
    要注意的几点是:

    1)如果指定的抢占式优先级别或响应优先级别超出了选定的优先级分组所限定的范围,将可能得到意想不到的结果;

    2)抢占式优先级别相同的中断源之间没有嵌套关系;

    3)如果某个中断源被指定为某个抢占式优先级别,又没有其它中断源处于同一个抢占式优先级别,则可以为这个中断源指定任意有效的响应优先级别。

    来 自:https://blog.csdn.net/andrewgithub/article/details/53758968

    展开全文
  • Java多线程03_线程状态、优先级、用户线程和守护线程 线程方法: setPriority() 更改线程优先级 static void sleep() 线程休眠 void join() 插队 static void yield() 礼让 void interrupt() 中断...

    Java多线程03_线程状态、优先级、用户线程和守护线程


    在这里插入图片描述


    线程方法:

    setPriority()				更改线程优先级
    static void sleep()			线程休眠
    void join()					插队
    static void yield()			礼让
    void interrupt()			中断线程
    boolean isAlive()			是否存活
    

    停止线程:

    不推荐JDK提供的stop()、destory()方法 【已废弃】

    推荐让线程正常停止,不要死循环!

    建议使用一个标志位进行终止,当flag=false,则终止线程运行

    public class TestStop implements Runnable{
    
    	private boolean flag = true;
    	
    	@Override
    	public void run() {
    		int i = 0;
    		while(flag) {
    			System.out.println("run...Thread"+i++);
    		}
    	}
    	
    	//设置公开方法利用标志位停止线程
    	public void stopThread() {
    		this.flag = false;
    		System.out.println("线程停止了");
    	}
    	
    	public static void main(String[] args) {
    		TestStop testStop = new TestStop();
    		new Thread(testStop).start();
    		
    		for(int i=0;i<1000;i++) {
    			System.out.println("main...,"+i);
    			if(i==900) {
    				testStop.stopThread();
    			}
    		}
    		
    	}
    	
    }
    

    线程休眠:

    sleep方法存在异常:InterruptedException

    sleep时间结束,线程进入就绪状态

    每个对象都有一个锁,sleep不会释放锁

    Thread.sleep(1000);
    

    线程礼让:

    让当前执行的线程暂停,但不阻塞

    将线程从运行状态转为就绪状态

    礼让不一定成功,看cpu心情

    Thread.yield();
    

    Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞(插队)

    main线程和Thread线程交替执行,当main线程执行到200时,Thread线程插队,一直到执行结束,main线程才能重新执行

    package com.blu.demo1;
    
    public class TestJoin implements Runnable{
    
    	@Override
    	public void run() {
    		for(int i = 0;i < 1000;i++) {
    			System.out.println("vip线程正在执行....."+i);
    		}
    	}
    	
    	public static void main(String[] args) throws InterruptedException {
    		TestJoin testJoin = new TestJoin();
    		Thread thread = new Thread(testJoin);
    		thread.start();
    		
    		for(int i = 0;i < 1000;i++) {
    			if(i==200) {
    				thread.join();
    			}
    			System.out.println("main线程正在执行....."+i);
    		}
    	}
    
    }
    

    getState()监测线程状态:

    返回枚举类型:

    NEW	
    RUNNABLE
    BLOCKED
    WAITING
    TIMED_WAITING
    TERMINATED
    

    线程优先级:

    线程优先级用1-10之间的整数表示,1为最低优先级,10为最高优先级

    主线程优先级默认为5,且不可修改

    枚举
    Thread.MAX_PRIORITY = 10
    Thread.NORM_PRIORITY = 5
    Thread.MIN_PRIORITY = 1

    优先级高不一定先执行,由CPU调度决定

    public class TestPriority {
    	
    	public static void main(String[] args) {
    		//主线程优先级
    		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    		MyPriority myPriority = new MyPriority();
    		Thread t1 = new Thread(myPriority);
    		Thread t2 = new Thread(myPriority);
    		Thread t3 = new Thread(myPriority);
    		Thread t4 = new Thread(myPriority);
    		Thread t5 = new Thread(myPriority);
    		Thread t6 = new Thread(myPriority);
    		//设置优先级
    		t1.start();
    		t2.setPriority(1);
    		t3.setPriority(4);
    		t4.setPriority(Thread.MAX_PRIORITY);
    		t5.setPriority(5);
    		t6.setPriority(7);
    		t2.start();
    		t3.start();
    		t4.start();
    		t5.start();
    		t6.start();
    	}
    	
    }
    
    class MyPriority implements Runnable{
    
    	@Override
    	public void run() {
    		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    	}
    	
    }
    

    守护线程

    线程分为用户线程(比如main)守护线程(比如gc)

    虚拟机必须确保用户线程执行完毕,不用等待守护线程执行完毕

    当只剩下守护线程时,JVM就会退出,只要存在一个用户线程,JVM就不会退出

    public class TestDaemon {
    	
    	public static void main(String[] args) {
    		God god = new God();
    		You you = new You();
    		Thread thread = new Thread(god);
    		thread.setDaemon(true);
    		thread.start();
    		new Thread(you).start();
    	}
    }
    
    class God implements Runnable{
    	
    	@Override
    	public void run() {
    		while(true) {
    			System.out.println("上帝保佑着你");
    		}
    	}
    }
    
    class You implements Runnable{
    
    	@Override
    	public void run() {
    		for(int i = 0;i<=100;i++) {
    			System.out.println("你开心地活了"+i+"年");
    		}
    		System.out.println("GoodBye,World!");
    	}
    	
    }
    
    展开全文
  • 优先级反转

    2019-09-05 17:43:39
    优先级反转 英文名叫做 Priority Inversion,一句话概括它的意思:低优先级任务要比高优先级任务先执行。 先明白一些背景知识 1.操作系统是多任务的 2.任务之间谁都可以得到执行,是通过任务调度来完成 3.任务调度...

    简介

    优先级反转 英文名叫做 Priority Inversion,一句话概括它的意思:低优先级任务要比高优先级任务先执行

    先明白一些背景知识

    • 1.操作系统是多任务的
    • 2.任务之间谁都可以得到执行,是通过任务调度来完成
    • 3.任务调度有多种算法,常见的有:
      • 罗宾环调度算法:Round-robin scheduling algorithm
      • 基于优先级的调度算法:Priority-controlled scheduling algorithm
    • 4.一般操作系统用的就是优先级调度算法,根据优先级别高低去调度,也就是优先级高的先执行,优先级低的后执行;
      • 任务调度器,总是先去激活所有任务中优先级别最高的任务,且该任务处于就绪状态,然后让它执行
      • 任务有多种状态:就绪,挂起,执行等;常见的如:需要某种资源时被别的任务占用了,那么当前任务就不得不挂起,先让被占用资源的任务执行
    • 5.任务一般被称为:进程,或者粒度更小的线程

    详细解释下为什么

    假设有以下条件

    • 1.任务A (低优先级)
    • 2.任务B (中优先级)
    • 3.任务C (高优先级)
    • 4.资源

    步骤

    • 1.已知任务调度器总是去激活所有任务中优先级最高的,且处于就绪状态的任务,去执行;但是当某个最高优先级的任务A,由于其所需要的某个资源被低优先级任务C所占用,而且还没有释放,那么高优先级任务A就被阻塞了。
    • 2.按照调度规则:
      • 此高优先级任务A,必须等到低优先级任务C把自己占用的资源释放后,才能继续运行;
      • 但是要等到低优先级任务C释放其所占用的资源的话,则很明显,必须要让低优先级任务C 先去执行,然后等低优先级任务C执行完毕并释放资源后,高优先级任务A就能得到的那个资源了;
      • 但是,问题就是:在高优先级任务A执行的这段时间内,某个中优先级任务B已经处于就绪状态了,所以当高优先级任务A,由于所需要的资源被占用而挂起,然后中优先级任务B,由于比低优先级任务C的优先级高,所以被调度执行,然后中优先级任务B就一直执行,知道结束。
    • 3.这种情况就是:一个中等优先级任务B,却比一个高更优先级的任务A 先执行,这就叫做优先级反转

    在这里插入图片描述

    问题:
    本来应该是优先级最高的任务A先执行的,结果却变成了,比高优先级任务A要低一些的中优先级任务B先执行了。
    优先级反转如名字一样,就是他们的优先级别互换了一下(反转了一下)。

    有的朋友会问了,反转就反转了呗?,有什么大不了的,程序还不是照样运行吗?

    优先级反转的有和危害

    实话说,当我刚学习计算机的时候,对计算机的概念都真的只是个概念,背后的技术和逻辑学的也是云里云雾的,而慢慢的成长,就会发现以前不理解的知识,现在看起来很重要很重要,而且也容易理解些了。

    对于实时系统,最重要的指标就是:确保任务执行时间是可预测的,即涉及到最后时间点等
    比如:
    要确保,某个时刻在执行某个任务,都不能超过某个时间等

    危害一

    • 由于优先级反转,造成任务调度时,时间的不确定性。
    • 时间的不确定,破坏了实时系统的实时性
    • 严重时可能导致系统崩溃

    危害二

    • 由于本身基于优先级设计的任务,每个优先级不同的任务,往往都对应着实际的现实中执行的任务
    • 由于优先级反转,导致了低优先级比高优先级先执行了
    • 直接导致任务错乱,逻辑错乱了
    • 程序可能也就异常了
    • 数据可能也会错误的
    现实中最有名也是第一例

    当年的火星探路者号(Mars Pathfinder)就由于优先级反转问题而导致火星探路者号内部程序的执行逻辑出错。
    在1997年7月4号发射后,在开始搜集气象数据之后没几天,系统就(无故)重启了。
    后来,被相关技术人员找到了问题根源,就是优先级反转所导致的,然后他们就发送了一个简单的C程序到火星探路者上,以修复。
    可以看这里:http://blog.jobbole.com/42802/

    如何解决或避免优先级反转的问题了?

    既然危害那么大,也发生了那么多年,肯定早就解决了。
    解决方法就是:

    对于占了高优先级任务A的某种所需资源的低优先级任务C,赋予给低优先级任务C和高优先级任务A相同的优先级;
    所以执行顺序就是 高优先级任务A执行时被阻塞了 -> 执行高优先级任务C(原来是低优先级) -> 执行剩下的任务A -> 执行中优先级的任务B
    看图

    在这里插入图片描述

    仔细对比这张图和上一张图的区别,Priority Inheritance (优先级继承)

    Priority Celling(最高优先级)

    由于临界区,mutex(互斥)了公用的资源部分,则赋予相同优先级。
    由此,凡是想要用到临界区的资源的任务,要在进入临界区之前,都要将临界区的优先级赋予给该任务,从而使得该任务有了相同的优先级而不被打断,才可以保持继续运行,直到用过资源后,退出临界区,这样就避免了,被高优先级A发现某资源被低优先级C占用之类的问题了。

    好了,就说到这里,相信读者应该很清晰明白了优先级反转的原因和解决方案了吧。?

    展开全文
  • iOS的锁中有一个自选锁OSSpinLock , 这个api被标记为不推荐 , 理由就是会产生优先级反转的问题, 当时并不是特别理解这个优先级反转 . 后来在看一本书 <算法之美> 里在讲进程调度,优先级调度算法时也提到优先级...
  • STM32(Cortex-M3)中有两个优先级的概念——抢占式优先级和响应优先级,有人把响应优先级称作’亚优先级’或’副优先级’,每个中断源都需要被指定这两种优先级。 具有高抢占式优先级的中断可以在具有低抢占式优先级...
  • 优先级继承和优先级天花板

    千次阅读 2018-04-30 13:35:58
    优先级继承 当一个任务阻塞了若干个任务时,若阻塞任务有...给每个信号量设置一个优先级天花板,优先级天花板的值大于所有使用该信号的任务的优先级,当某个任务得到该信号量时,将其优先级置为优先级天花板的值。...
  • 普通优先级线程优先级默认值

    千次阅读 2018-05-08 14:28:43
    普通优先级线程优先级默认值为5
  • C运算符优先级

    2018-05-03 11:08:09
    C运算符优先级, C运算符优先级, C运算符优先级, C运算符优先级, C运算符优先级, C运算符优先级,
  • 那么本文将介绍一下另一种特殊的队列结构,叫做 优先级队列。 上一篇文章的跳转链接—— 公众号:Lpyexplore的编程小屋 关注我,每天更新,带你在python爬虫的过程中学习前端,还有更多电子书和面试题等你来拿 ...
  • 运算符优先级

    千次阅读 2019-06-12 00:10:29
    运算符优先级
  • 1、802.1P优先级(有时也称COS优先级): 802.1p用户优先级定义在二层802.1Q 标签头中的TCI字段中。,和VLAN ID一起使用,位于高位起16-18bit字段,长度3bit,取值范围0-7,0优先级最低,7优先级最高 TPID(Tag...
  • 优先级任务被低优先级任务阻塞,导致高优先级任务迟迟得不到调度。但其他中等优先级的任务却能抢到CPU资源。 举个栗子: 进程A,进程B,进程C。优先级依次递增。 进程C优先级最低,但进程C最先运行(占有锁...
  • C语言运算符优先级(超详细)

    万次阅读 多人点赞 2017-06-07 11:44:16
    每当想找哪个运算符优先级高时,很多时候总是想找的就没有,真让人气愤!现在,终于有个我个人觉得非常全的,分享给大家,欢迎拍砖! C语言运算符优先级 优先级 运算符 名称...
  • FreeRtos 任务优先级和中断优先级

    千次阅读 2019-07-01 17:36:19
    中断优先级和任务优先级的区别: 1.简单的说,这两者之间没有任何关系,不管中断的优先级是多少,中断的优先级永远高任何任务的优先级,即在执行的过程中,中断来了就开始执行中断服务程序, 2.对应STM32F103 F...
  • //对中断源进行分组,每组有一个抢占优先级和响应优先级。 上面的理解是错误的,事实上,所有中断源都是一个组。 这个操作应该称之为设置中断优先级的控制模式(控制组别)。 清楚地说是:这里不应该用“组”这个...
  • C++进程优先级调度进程优先级调度进程优先级调度C++进程优先级调度进程优先级调度进程优先级调度
  • 优先级反转:准确来说,指的是一种现象,并非一项任务调度技术,即高优先级任务被低优先级任务阻塞推迟的行为被称为“优先级反转”。这是一种不合理的行为方式,如果把这种行为再进一步放大,当高优先级任务正等待...
  • 中断优先级

    2020-01-13 13:36:17
    中断优先级 分组方法 以及中断强度优先级和响应优先级的关系: 注意: 例如:已经设置好分组为2 抢占和响应优先级分别为10 10即抢占优先级为2,响应优先级也为2;如果这时改变分组为3,则抢占优先级为101 0...
  • 然而这16级可编程优先级并不一定都是抢占优先级,它会被优先级组分成两类:抢占优先级和亚优先级。 NVIC中有一个寄存器是“应用程序中断及复位控制寄存器”(内容见表7.5),它里面有一个位段名为“优先级组”。该位...
  • freeRTOS优先级

    2019-04-09 10:46:56
    freeRTOS优先级,数值越大,优先级越高。 优先级0是空闲任务,已经被占用,优先级最低。 然而,不巧的是,ucos恰恰相反,数值越低,优先级越高。
  • 路由优先级

    千次阅读 2020-04-10 00:22:49
    每一个路由协议都有协议优先级(数值越小,优先级越高),当有多个路由信息时,选择是最高优先级的路由作为最佳路由。 路由类型 direct ospf static rip 优先级 0 10 60 100...
  • C语言优先级

    千次阅读 多人点赞 2019-06-04 10:37:40
    C语言优先级 | | | |–|--|
  • 线程优先级

    千次阅读 2019-01-10 17:34:26
    线程的优先级 在操作系统中,线程可以划分优先级,Cpu优先执行优先级高的线程的任务。 在java中线程优先级分为1~10,如果小于1或者大于10,则jdk报illegalArgumentException()异常。 设置线程优先级使用set...
  • 静态优先级:(定义在进程描述符中的:static_prio) 动态优先级:(定义在进程描述符中的:prio) 实时优先级:(定义在进程描述符中的:rt_priority)   静态优先级:  定义:他不随时间改变,内核不会主动修改它,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,015
精华内容 44,406
关键字:

优先级