优先级1



优先级2



优先级3



优先级4



优先级5



优先级6



优先级7



优先级8-13

一、抢占优先级比子优先级的优先权更高，这意味抢占优先级更高的中断会先执行，而不管子优先级的优先权，数值越低优先级越高。

二、同理，如果抢占优先级相同，那么就会比较子优先级，子优先级更高的中断将会先被执行，数值越低优先级越高。

三、当两个中断源的抢占式优先级相同时，这两个中断将没有嵌套关系，当一个中断到来后，如果正在处理另一个中断，这个后到来的中断就要等到前一个中断处理完之后才能被处理。如果这两个中断同时到达，则中断控制器根据他们的响应优先级高低来决定先处理哪一个；如果他们的抢占式优先级和响应优先级都相等，则根据他们在中断表中的排位顺序决定先处理哪一个。

四、既然每个中断源都需要被指定这两种优先级，就需要有相应的寄存器位记录每个中断的优先级；在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()			中断线程
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!");
	}
	
}

简介
优先级反转 英文名叫做 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占用之类的问题了。
好了，就说到这里，相信读者应该很清晰明白了优先级反转的原因和解决方案了吧。?