【探讨】你真的了解 RTOS 的多线程吗?欢迎各位大佬来分析~

发表在 Kernel2019-12-9 17:47 [复制链接] 24 632

本帖最后由 aozima 于 2019-12-10 11:51 编辑
* }6 w5 L5 i$ ], q+ Z, h+ _9 C5 d! n( D5 Y+ |
在 RT-Thread msh(优先级20) 运行 demo1 demo2  demo3 3条分别打印什么,为什么这样打印(先别运行哦,直接分析看你了解透彻没)?
  y  l3 o: l7 z# y% p* [$ X% B先仅仅作者能看回帖,2天后揭晓大家的分析~( o2 {8 R+ L. P6 M: ]- @& w

! @3 z8 {8 n& D* `
  1. #include <rtthread.h>
    3 D1 Q) l2 \' L* x7 B& w2 B
  2. 6 }  I6 _; Q4 A2 `/ m
  3. static void thread1_entry(void *parameter)- S6 O% W3 F. l: c* }
  4. {' P" y. D- m8 t7 F: f
  5.     rt_thread_mdelay(100);5 @6 R% c, f9 q- D
  6.     while (1)- u) ~+ M$ Z; w8 B
  7.     {
    4 B6 v; c& ?  X, C& ~- s
  8.         rt_kprintf("1");
    ( D% G8 d4 p* T) @0 p+ w
  9.     }
    0 H9 d( k5 w! z
  10. }
    . ^1 U8 m, u, m, |# m

  11. , a) X2 I$ M' }
  12. static void thread2_entry(void *parameter), M$ u( o. ~% ~2 Y- L( r+ M
  13. {& \$ X( \" O4 b# d+ V
  14.     rt_thread_mdelay(500);
    * d: K5 y9 A9 _% k" h1 J, l
  15.     while (1)- R7 ^& r5 m1 J2 H8 u8 u
  16.     {) ^; X' w  s. o' I  t1 P
  17.         rt_kprintf("2");+ S# `" R% R/ v3 O* K
  18.     }
    & X. J! j( j* k1 j& S4 l( i
  19. }
    4 q1 m; |1 L6 `$ d: V4 h
  20. : Z( S& R0 H/ Y+ R- u: }7 B  d1 ]
  21. static void sample1_demo(void)
    & ]; N8 m: ]* v* M7 C; m9 s
  22. {1 k* G* v! a: M- ?, E6 s
  23.     rt_thread_t tid1 = rt_thread_create("task1", thread1_entry, RT_NULL, 512, 25, 5);
    * w4 c5 X5 P5 E4 z5 z3 ^$ l
  24.     if (tid1 != RT_NULL)
    : G7 ^0 o" r* }1 E
  25.         rt_thread_startup(tid1);
    0 \7 ?* P0 Y8 x; b7 }; E; R
  26. 5 Q% C4 t7 F; I6 y" s
  27.     rt_thread_t tid2 = rt_thread_create("task2", thread2_entry, RT_NULL, 512, 10, 5);
    4 {! m9 D; `0 X# R6 C& m& L( A
  28.     if (tid2 != RT_NULL)
    0 u+ w( J& W6 k, y' a  V, W
  29.         rt_thread_startup(tid2);4 ]4 t* q1 a  n/ ]
  30. }
    ) Z( I! W& C; E0 n+ t
  31. MSH_CMD_EXPORT(sample1_demo, sample1_demo);
    ( Z% b* l2 n6 P) e! t

  32. ( }/ ^- b8 X& y4 L% D0 ~8 J- z
  33. static void sample2_demo(void)
    9 m' T4 I* Q+ D& v
  34. {/ C$ E% M. i4 n$ F4 ^. n- F( ?* X
  35.     rt_thread_t tid1 = rt_thread_create("task1", thread1_entry, RT_NULL, 512, 25, 5);7 I! P+ r' s% o% D& \) l/ F$ k/ p% A
  36.     if (tid1 != RT_NULL)9 @, Q5 o3 ~  v' u" ]7 B
  37.         rt_thread_startup(tid1);
    8 T$ Q9 h4 c" Q# D$ n
  38. # Y/ A! ^3 y) @- s* g
  39.     rt_thread_t tid2 = rt_thread_create("task2", thread2_entry, RT_NULL, 512, 25, 5);- [% @+ y3 ?1 v2 Y1 i  p
  40.     if (tid2 != RT_NULL)! [& p7 V5 s( n: N% y$ N) |
  41.         rt_thread_startup(tid2);
    ) K! v6 h. Y- W1 ~) n$ ~/ y6 |/ n
  42. }
    $ K; Y5 V& |+ R8 i
  43. MSH_CMD_EXPORT(sample2_demo, sample2_demo);
    - D9 T! s2 f$ w& H3 k
  44. ! H& t1 _3 O& Q  l! B; K
  45. static void sample3_demo(void)
    % M( M" o, _4 M& d( T3 N5 D
  46. {( M3 U$ _2 X( N; u( ^: V
  47.     rt_thread_t tid1 = rt_thread_create("task1", thread1_entry, RT_NULL, 512, 10, 5);+ p) h, E, Y; {9 M8 |# S) i( m: r
  48.     if (tid1 != RT_NULL)# O/ d9 @: d% `
  49.         rt_thread_startup(tid1);1 d) G* v, F4 W7 u
  50. : t4 r# a; A+ ~4 f! p- Z
  51.     rt_thread_mdelay(600);
    1 N) g& n( H- Q# N9 Z

  52. ' n' c* @' x" [' a$ {  v# X" c
  53.     rt_thread_t tid2 = rt_thread_create("task2", thread2_entry, RT_NULL, 512, 10, 5);+ C$ q1 p) V4 n. }( u# |- Y5 j' L  e
  54.     if (tid2 != RT_NULL)! A# f: @) W$ q4 z$ d$ S
  55.         rt_thread_startup(tid2);7 j+ x7 V7 w  x& Q/ v
  56. }/ k* e3 Y( Y8 [: U. n
  57. MSH_CMD_EXPORT(sample3_demo, sample3_demo);
    ) V5 A2 X+ s! @  u$ e9 l

  58. 3 j2 f' @3 R% S0 y
  59. # ]: g8 u: d; s$ ^2 B
复制代码

0 \; ?+ [: `# m, R( f
3 |& k0 p% D  z6 B* Q' z
使用道具 举报 显示全部楼层 回复
最新评论 | 正序浏览
显示全部楼层 |楼层直达:
发表于 2019-12-9 18:13:45 | 显示全部楼层
这就是线程优先级抢占的例子嘛
7 r' l* k% d" V) A6 o
, t# Y, q. [, E5 m9 l7 O" e0 \由于shell线程优先级是20 ,所以楼主分了三种情况:, j& B, ^2 c% ^0 M3 `
1、线程1优先级<20,线程2优先级>20
. f9 c5 X4 O) H5 T2、线程1与线程2优先级均大于20
5 t% U; v5 _2 N3、线程1与线程2优先级均小于20
( ?9 a* a, B! Q0 u% |3 l, ~0 [/ I- k* n8 |/ D& M
这时候,在shell线程中,都是先创建线程1,先启动线程1的情况下,就会有与shell线程优先级的一个比较了,然后导致运行结果有所差异。
( ~+ B  t& h1 k  B. B3 a
7 g7 z& u2 d. _7 f$ Z分析上面的3种情况:
( Z3 I9 M$ ]8 D# V
0 O& [, {9 V( k* D/ P. E1 T" ?1、线程1此时优先级高,启动后直接开始运行,等待线程1挂起的时候,才能开始运行shell里面的创建线程2,然后启动并运行线程2$ T; {9 ?5 L# ]3 q+ d& ^0 C
+ i& l( H  _9 i% U# `+ ^8 r
2、均大于20,此时2个线程的优先级较低,即使创建并启动线程1,此时线程1不会运行,而是转为就绪态,等待shell线程创建完线程2并启动后,shell运行完毕,线程1才开始运行,线程1让出时,线程2运行。除此之外,由于优先级相同。两者还有时间片轮转的情况。
4 _# Z$ }# i* W% y" K- p& _4 v+ j9 A7 P) `8 \/ B$ q" r
3、都小于20,就是优先级都很高,shell创建线程1后先运行线程1,线程1挂起时运行shell创建线程2............
4 t+ |; S) a; i  L( q  e. Y/ y8 D9 i- ^/ G9 i. ^7 k9 a
是不是往创建2个线程之间再加一个打印的测试语句更好
9 D& Q3 s3 g5 j
  1. static void sample_demo(void)
    . t* F. D- c  V. L
  2. {' N% i% J3 m; ?; A6 D3 c
  3.     rt_thread_t tid1 = rt_thread_create("task1", thread1_entry, RT_NULL, 512, 10, 5);
    1 d4 v# n" A8 f+ Z2 M' G& H0 c3 q& D2 n
  4.     if (tid1 != RT_NULL)
    9 u+ t7 V5 o9 c% u9 E/ b8 t: b
  5.         rt_thread_startup(tid1);6 o! C4 H4 t2 o; b+ V
  6. 9 c; o: c9 X8 q5 g
  7. //打印xxxxxxxxxx) {% l. |( p3 c8 U' i

  8. 1 M, K6 T' f" O+ v( N
  9.     rt_thread_t tid2 = rt_thread_create("task2", thread2_entry, RT_NULL, 512, 10, 5);+ l) s% p+ c2 p4 s6 F! z
  10.     if (tid2 != RT_NULL)
    / C6 @+ }$ Y8 A* C  B0 e, n; H
  11.         rt_thread_startup(tid2);
    ! C6 P/ k, l$ k! u
  12. }
复制代码
使用道具 举报 回复
发表于 2019-12-9 18:16:56 | 显示全部楼层
yangjie 发表于 2019-12-9 18:134 y! ~! V3 b% `, a2 R
这就是线程优先级抢占的例子嘛" W1 `) L0 J* t' q2 S
  r/ x/ ]8 d4 {9 h5 N
由于shell线程优先级是20 ,所以楼主分了三种情况:
( e* o. q$ m# q' Q  l9 b
demo3改了下,少打一行,再试试~
使用道具 举报 回复
发表于 2019-12-9 18:21:34 | 显示全部楼层
yangjie 发表于 2019-12-9 18:13
5 D5 P/ w4 D- |2 D$ T( g4 F这就是线程优先级抢占的例子嘛' V% t2 a- d# m, I/ z7 e/ B

. O7 ?5 L8 R1 x. S! E7 b5 }( K9 M( _1 h由于shell线程优先级是20 ,所以楼主分了三种情况:
) j* P* h, u  ?7 [" _
打印结果呢
使用道具 举报 回复
发表于 2019-12-9 18:50:01 | 显示全部楼层
demo1:: B$ b8 n7 S( \8 O6 s" u, c. t: `
先打印400ms的1, 然后一直打印2
+ _3 Z! w% J; N9 u" K& |: z% d$ x  ddemo2:. N: w4 }& f2 C. d$ q$ b/ e) u
先打印400ms的1, 然后打印5ms的2,再打印5ms的1,这样交替下去
. }. w3 L. E' c) F9 i. Jdemo3:) S* j; X" Y" ^; O; R/ V3 R7 |
一直打印17 b; E! k+ S$ @$ b, r
. }8 q2 {* C+ p
难道这么简单?
使用道具 举报 回复
发表于 2019-12-9 19:07:36 | 显示全部楼层
分析一波这个题目:
/ ]# ]* I  p4 M9 J5 {DEMO1: 创建了两个任务 task 1 task2 他们的区别在于任务的优先级,以及start up的顺序。 start up只是把这给任务交给了调度器,但是这个时候调度还没有发生,调度器是在就绪列表中选择优先级最高的先执行,所以DEMO1应该是task2 先执行。$ l- I% O' {+ D; w9 H
! d2 ?0 c' i/ h% Q* R
DEMO2:除了start up的顺序不一样其他一致,这样同优先级的任务先start up的任务先执行,剩下的轮转靠的是时间片。所以DEAM2 task1先执行
! D- B& y; q0 \8 U, k% y" g* w
1 b/ G: L; \, ?/ r# Q' a( j% ?DEMO3:task1的优先级低,task2的任务优先级高,但是task1 start up之后delay了,这个时候调度器就介入了,那么task1已经执行了,但是task2还没有完成创建,所以DEMO3 是task1先执行。
使用道具 举报 回复
发表于 2019-12-9 21:40:22 来自手机 | 显示全部楼层
该帖仅网管可见
使用道具 举报 回复
发表于 2019-12-10 08:50:27 来自手机 | 显示全部楼层
本帖最后由 lucifer 于 2019-12-10 08:56 编辑 2 W) b7 I% l8 ~: U  C  C
6 q3 H; P6 p/ J% L) O( e. p3 y1 f5 `4 t
2........
; r9 L8 I' @) e, T' n9 c. y1.....2........1........2.......1 O# O- H: y0 [- X/ ]
1...............2.......1.......2........
使用道具 举报 回复
发表于 2019-12-10 09:36:50 | 显示全部楼层
偷偷运行了一下,发现果然分析错了,哈哈哈,一开始以为低优先级的死循环不能被高优先级的打断(只能主动让出处理器)。学到了○( ^皿^)っHiahiahia…
使用道具 举报 回复
发表于 2019-12-10 09:52:54 | 显示全部楼层
一直打印2,因为优先级大于msh,并且while(1)里面没有delay
使用道具 举报 回复
发表于 2019-12-10 09:54:37 | 显示全部楼层
应该先打印1 再一直打印2
使用道具 举报 回复
发表于 2019-12-10 10:28:32 | 显示全部楼层
本帖最后由 123456 于 2019-12-10 10:29 编辑
& ~6 v: w; k" |  N
! y1 Q5 G, Y7 l1.              2 1 2 1 2 1.。。。。。。  u( \" O0 k6 Y1 c
2.              111112111112111112。。。。。。
. t# k6 g, |8 w7 q; |# r- }7 P% q3.              111111211111121111112 。。。。。。4 Y  W! ]1 a& ^8 `) A
$ {. T( v9 m! q( d) j% ?4 k3 T
一句话:2 V. v6 W1 Y( u
1.优先级第一,即使优先级高的线程挂起,低优先级的线程也不会获取执行权。
5 T& @5 A& Q- Q/ `, v6 n2.优先级一样的情况下,采取时间片轮旋,顺序循环执行。
使用道具 举报 回复
发表于 2019-12-10 11:57:08 | 显示全部楼层
小木匠 发表于 2019-12-9 18:502 o; }' K/ W* K- B  G
demo1:2 [& h; i' S8 F) N' B! D) E
先打印400ms的1, 然后一直打印2. K$ r3 i7 R1 c( `/ f
demo2:
8 W2 S+ O9 f+ p  N; u
大佬来分析一波为什么这么打印~
使用道具 举报 回复
发表于 2019-12-10 11:57:53 | 显示全部楼层
heyuanjie87 发表于 2019-12-9 21:400 C6 f0 b! C. U* t: F" w
该帖仅网管可见
" L8 a8 t2 K9 \( B
现在都可见了,杀猪哥不来一个分析吗
使用道具 举报 回复
发表于 2019-12-10 11:58:15 | 显示全部楼层
whj467467222 发表于 2019-12-9 19:072 R+ k" v) Z' h  ?1 t  z. ^1 `$ W
分析一波这个题目:
9 _% j% ?7 k! Z  vDEMO1: 创建了两个任务 task 1 task2 他们的区别在于任务的优先级,以及start up的顺 ...
4 T0 i$ h5 G( l
打印结果呢?
使用道具 举报 回复
发表于 2019-12-10 14:15:08 | 显示全部楼层
123456 发表于 2019-12-10 10:28
6 ^1 n: m! a7 {" M9 X( F4 m1 l* Q, S7 l1.              2 1 2 1 2 1.。。。。。。" `: Y1 r, v: E8 Y) _
2.              111112111112111112。。。。。。( A. _3 W: x1 P8 s" @) L5 N9 Z! A1 l$ u
3.           ...

: O' N! _5 P& Z3 L: m* C; z不对,不信你自己跑下代码看看
使用道具 举报 回复
发表于 2019-12-13 08:56:09 | 显示全部楼层
不公布一下正确结果吗
使用道具 举报 回复
发表于 2019-12-13 09:53:11 | 显示全部楼层
小木匠 发表于 2019-12-13 08:56
5 o' E$ Y: b8 e$ [; h不公布一下正确结果吗

# r. u& F: e0 m马上
使用道具 举报 回复
发表于 2019-12-13 09:56:03 | 显示全部楼层
本帖最后由 liu2guang 于 2019-12-13 10:53 编辑
! V- `2 X) x1 r6 d' ?
6 m+ W! N( @2 K# w1 ], P! |1. 先说下现象:
5 S! N7 u: u) N1 y0 z" kdemo1:先打印1,后只打印2: J( w% h  [4 h6 k* N6 s/ G" e
demo2:先打印1,后2/1交替" _( V* q2 Z* P
demo3:只打印1( V9 M. H, k: U) K% h
7 `# K7 l" x7 I: A! F+ |: s
demo1打印:# I" H6 Y7 A2 ^* T3 o1 m

demo1

demo1

( j/ R/ c1 Q; s8 Z2 H* A! ?
  ^7 [5 u8 I% e, a, [# k5 Mdemo2打印:
9 Z+ ^" I7 c1 A; X0 H# A: p

demo2

demo2
+ Y5 F* g5 v/ `: k) x
" Z# i9 o) E% `3 a$ |: A2 K
demo3打印:
8 ^+ ^# j6 T0 {' e+ m/ r3 J  c0 {5 s2 G

demo3

demo3
6 h2 ]& J/ E4 M: L* v. x3 R
/ M# {( f. T& V; K
2. 代码分析  y! A/ r$ `0 p. {  J: z0 L
' x  L, v* ^- |; O" ]2 G
知识点:( M5 C. q7 R5 x& ^0 {8 H
1. 全抢占式调度原则,进入调度后永远选择 就绪列表(包含运行状态的线程)中的最高优先级且拥有时间片的任务运行。
% U% V# z: e! i% c4 n2. 延时会立刻挂起当前线程,进入调度9 N# j- w. I& q6 \# F8 G
3. 启动线程的时候会立刻调度
0 D) N' V# i/ t& S2 O6 K! `
1 f/ i7 G+ N% M( x# Q: Bdemo1:1 A+ x* Q6 W0 z' U: U: F
1. 我们在shell中运行sample1_demo命令,那么sample1_demo的运行环境就是在tshell线程中的,优先级为20。$ T! @- G0 ~+ y
2. 先调用rt_thread_create创建task1线程,优先级25并启动线程,这个时候会立刻进入调度,系统中有 idle tshell task1 3个线程,tshell是就绪列表(包含运行状态的线程)中的最高优先级且拥有时间片的线程,所以满足调度条件继续运行tshell线程。# C8 `5 p! F; z" ?  V  Y; H6 c/ ^
3. 那么继续运行tshell线程中的创建 sample2_demo 的代码。task2线程的优先级为10,启动task2线程会立刻调度,由于调度原则所以先运行 thread2_entry 线程。
8 `1 v3 M6 y) x4. 但是 task2 先运行了延时函数就把自己挂起了,所以这个时候又触发调度了,系统中有 idle tshell task1 task2 4个线程,tshell满足调度条件,那么又恢复到之前tshell被打断的地方继续运行。
# [, T. Z2 e) Q3 r# Q- ~5. sample2_demo函数退出,进入tshell等待命令挂起自己的状态,这个时候又触发调度,当前系统中还有 idel处于就绪状态,这个时候调度发现idle是最高,就运行idle线程
- s/ L: E- R/ p2 s6. 等待100ms超时后,由ostick中断的到来触发调度,这个时候task1恢复就绪状态,那么当前系统中满足运行条件的线程为task1,task1开始死循环打印1/ V7 `, V: B5 p5 W
7. 再过400ms后,由ostick中断触发的调度中发现task2恢复就绪状态,那么当前系统中满足运行条件的线程为task2,系统就运行task2,由于task2是死循环,就算1个ostick来一次的调度也并不能切换任务,因为他用于处于就绪列表(包含运行状态的线程)中的最高优先级且拥有时间片的线程,所以最终先打印1,后一直打印2
7 f5 u  c. A0 c2 h8 O( n. x) j+ J. I$ C/ U
demo2:! c' q* G; Y0 V: o- o
1. 我们在shell中运行sample2_demo命令,那么sample2_demo的运行环境就是在tshell线程中的,优先级为20。  X( ]& E* ]& p( D$ c8 e
2. 先调用rt_thread_create创建task1线程,优先级25并启动线程,这个时候会立刻进入调度,但是这个时候线程中有3个线程:task1,tshell,idel,由于tshell还是满足调度条件,所以先运行tshell线程中的创建sample2_demo的代码。
. J' ]; f  ^, M3. 接下来是创建task2线程优先级和task1一样是25并启动,又进入一次调度,但是这个tshell还是满足调度条件继续运行
/ d! @. m" M( o& z% o# h3 ?1 m4. sample2_demo函数退出,进入tshell等待命令挂起自己的状态,这个时候又触发调度,当前系统中还有 task1,task2,idel处于就绪状态,这个时候调度发现task1和2都是最高,那么由于task1先创建,那么先运行task13 Y$ i( |1 ?3 n' a* @8 w
5. task1函数中调用100ms延时挂起自己,又触发一次调度,当前系统中还有 task2,idel处于就绪状态,系统又调用task24 J% Z1 u. n! A  U' j$ J: @* K
6. task2函数又调用500ms延时挂起自己,又触发一次调度,当前系统中还有 idel处于就绪状态,系统就调用idle线程
! O( d. f$ l5 z, Y1 D7. 等待100ms超时后,由ostick中断的到来触发调度,这个时候task1恢复就绪状态,那么当前系统中满足运行条件的线程为task1,task1开始死循环打印1,但是这一次由于task1和task2优先级一样,那么他们都会被调度器调度,这个时候时间片就上场了,task1和task2都是5个tick的时间片,什么叫时间片?我们之前说了1个ostick会触发一次中断,线程有一个计数值这个计数值就是维护这个线程连续运行了多少个tick,那么调度器发现你已经运行了5个tick那么你就需要交出cpu到同优先级的其他线程,那么5个tick后就会运行task2,就这种情况会反复运行task1 task2线程,这个时候反复打印1 2,所以最终:先打印1,后2/1交替
1 \- @  D# u8 V8 H) \. E9 {/ C% E
) W1 J! p7 Y$ f/ S9 k+ _- kdemo3! ^% A+ y8 P. @! |7 K
1. 我们先在shell中运行sample3_demo命令,那么sample3_demo的运行环境就是在tshell线程中的,优先级为20。9 I( ]; g. O+ i' Z. e( ?
2. 首先创建10优先级的task1线程,启动task1线程触发调度,task1满足运行条件进入task1运行# B4 n; H  H$ [  l9 D4 f
3. 运行task1线程的时候,首先延时了100ms,所以task1挂起,当前系统中 就绪的线程只有tshell idle,那么又调度回tshell运行% t, p: {* Q" V* H* a  R% e' s
4. tshell这个时候调用600ms的延时,tshell被挂起了,所以调度器只能执行idle线程了,
4 y  @) g7 _2 S* f: ?5. 100ms过去后,task1恢复就绪状态并进入运行状态,由于task1是死循环,就算1个ostick来一次的调度也并不能切换任务,因为他用于处于就绪列表(包含运行状态的线程)中的最高优先级且拥有时间片的线程,那么task2永远不会被创建,那么也就是只会打印1,不会打印2% X) m6 n1 Z0 V9 b
4 N* o: \  a5 H' v; m
使用道具 举报 回复
发表于 2019-12-13 10:01:32 | 显示全部楼层
liu2guang 发表于 2019-12-13 09:56) ~, w& m( A( U6 h5 n& G9 O
1. 先说下现象:
( D# i. ^/ ?  e2 u/ V. ademo1:先打印1,后只打印2- l  h7 j7 V* C/ f! C8 j
demo2:先打印1,后2/1交替
  Y2 P, w- y) O
使用道具 举报 回复
发表于 2019-12-13 10:52:15 | 显示全部楼层
楼主,如果几个延时的操作,全部换成rt_thread_yield,结果又是如何呢?
使用道具 举报 回复
发表于 2019-12-13 10:53:50 | 显示全部楼层
123456 发表于 2019-12-13 10:522 b4 t: J8 _5 M& U% }
楼主,如果几个延时的操作,全部换成rt_thread_yield,结果又是如何呢?

% `$ h5 o' R  G* e可以参考下我上面的分析,不过yield不建议使用这个api
使用道具 举报 回复
发表于 2019-12-13 10:57:48 | 显示全部楼层
liu2guang 发表于 2019-12-13 10:53
3 K3 D% J+ O" k6 Z4 Y8 D. t# y可以参考下我上面的分析,不过yield不建议使用这个api

; U6 d9 w- s+ t7 E3 }" `. Iyield 应该采用那个API,指导一下。
使用道具 举报 回复
发表于 2019-12-13 11:04:52 | 显示全部楼层
123456 发表于 2019-12-13 10:57
( C/ Y$ b! s6 ^; J0 Z. \8 hyield 应该采用那个API,指导一下。
; h% L% N7 K5 o) R
线程有关利用 rt_thread_mdelay/delay/sleep 或者 IPC 相关api来交出 cpu 的执行权限,调度器最好不要手动挂起,例如yield,挂起线程,恢复线程,这样你系统调度可能就不合理,当然IPC还有延时其实就是用yield,挂起线程,恢复线程来实现的,所以说你能驾驭得住就可以用,但是99%的人驾驭不住的
使用道具 举报 回复
发表于 2019-12-13 13:14:52 | 显示全部楼层
楼主,一个线程延时的时候,该线程的时间片还会计数吗或者说消耗它的时间片吗,这里应该看哪里的代码分析啊
使用道具 举报 回复
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|RT-Thread开发者社区 ( 沪ICP备13014002号-1

有害信息举报电话:021-31165890 手机:18930558079

© 2006-2019 上海睿赛德电子科技有限公司

Powered by RT-Thread

快速回复 返回顶部 返回列表