优先级与释放时间分配与影响

发布于 2022-08-01 15:31:55 浏览：518 订阅该版

```c
/* 线程1 的入口函数*/
static void thread1_entry(void *parameter)
{
    rt_uint32_t count,i,j,k = 0;
    
    while (1)
    {

Display();/*18 tick*/

k ^= 1;
        if(k)
            GPIO_WriteBit(GPIOC,GPIO_Pin_5,1);
        else        
            GPIO_WriteBit(GPIOC,GPIO_Pin_5,0);     
        rt_thread_mdelay(100);        
    }
}
```

```c
ALIGN(RT_ALIGN_SIZE)
static char thread2_stack[4096];
static struct rt_thread thread2;
/* 线程2 入口*/
static void thread2_entry(void *param)
{
    rt_uint32_t count,i,j,k = 0;
    while (1)
    {
        count++;
        count %= 160;        
        Line(count,1,0xFF);

i = 15;
        while(i--)
        {
            LCDPaint(i*16 ,(count/16)*16, 16, 16, &GB2312[32*(15-i)],0); 
        }

if(key_flag)
        {
            Task();
            key_flag = 0;
        }
        
        k ^= 1;
        if(k)
            GPIO_WriteBit(GPIOC,GPIO_Pin_4,1);
        else        
            GPIO_WriteBit(GPIOC,GPIO_Pin_4,0);   
        rt_thread_mdelay(50);	        
   
    }
}
```

```c
ALIGN(RT_ALIGN_SIZE)
static char thread3_stack[4096];
static struct rt_thread thread3;
/* 线程3 入口*/
static void thread3_entry(void *param)
{
    rt_uint32_t count,i,j,k = 0;
    
    while (1)
    {  
        KeyScan();      /* 每10ms扫描按键一次 */         
        
        k ^= 1;
        if(k)
            GPIO_WriteBit(GPIOC,GPIO_Pin_6,1);
        else        
            GPIO_WriteBit(GPIOC,GPIO_Pin_6,0);           
		rt_thread_mdelay(10);      
    }
}
```

```c
/* 线程示例*/
int thread_sample(void)
{
    /* 创建线程1， 名称是thread1， 入口是thread1_entry*/
    tid1 = rt_thread_create("thread1",
                            thread1_entry, RT_NULL,
                            THREAD_STACK_SIZE<<4,/*THREAD_STACK_SIZE,*/
                            25, THREAD_TIMESLICE);
    
    /* 如果获得线程控制块， 启动这个线程*/
    if (tid1 != RT_NULL)
      rt_thread_startup(tid1);
                    
    /* 初始化线程2， 名称是thread2， 入口是thread2_entry */
    rt_thread_init(&thread2,
                    "thread2",
                    thread2_entry,
                    RT_NULL,
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    25 - 1, THREAD_TIMESLICE);
                    rt_thread_startup(&thread2);

/* 初始化线程3， 名称是thread3， 入口是thread3_entry */
    rt_thread_init(&thread3,
                    "thread3",
                    thread3_entry,
                    RT_NULL,
                    &thread3_stack[0],
                    sizeof(thread3_stack),
                    25 - 2, THREAD_TIMESLICE);
                    rt_thread_startup(&thread3);                    
    return 0;
}
```

```c
int main(void)//PRIORITY：10
{
    rt_uint32_t count = 0;	
    
    thread_sample();
    
    while (1)
    {
        rt_thread_mdelay(100);      
    }
}
```

优先级：main>thread3>thread2>thread1
但是thread3的输出PC方波容易被打乱，周期不是10ms
thread2的输出PC方波周期也不是50ms，
thread1的耗时Display();/*18 tick*/屏蔽则所有任务都正常，
请问为什么低优先级会影响高优先级线程？对于优先级和释放时间的分配策略有哪些？
谢谢