关于线程对象的继承问题

发表在 内核学习营2019-6-10 21:26 [复制链接] 6 157

根据官方书籍所述,内存池、thread、ipc、定时器、设备这几个对象,都是继承于object对象而来,为什么在定义数据结构的时候,thread对象要将object成员变量重写,而不像timer对象那样,直接对object对象继承呢?这其中是有什么原因吗?4 k3 e1 n  z4 {
object对象:2 T9 ~  |$ E/ X/ Q
  1. struct rt_object+ z9 d' Z- i- f, M- N! y; d
  2. {
    ) E) I7 X4 }, W3 h& K1 C6 P
  3.     char       name[RT_NAME_MAX];                       /**< name of kernel object */
    * A$ X" X+ m9 t  E# p6 A( V
  4.     rt_uint8_t type;                                    /**< type of kernel object */! A* g2 `% O+ E6 ]. K' i% `
  5.     rt_uint8_t flag;                                    /**< flag of kernel object */! s" d! c( g& Y! U7 ~6 N
  6. ! {0 U! c: ]. T- J# W
  7. #ifdef RT_USING_MODULE
    / q7 y$ N0 i- t- K4 x* P: x
  8.     void      *module_id;                               /**< id of application module */
    & \' Z$ k+ |& j  h! Q
  9. #endif: W  Y6 P. }/ C1 }# }
  10.     rt_list_t  list;                                    /**< list node of kernel object */0 s. @1 s( c3 B; _/ F; F; q7 u
  11. };
    ( P1 i: G( G0 O. L* \
  12. typedef struct rt_object *rt_object_t;                  /**< Type for kernel objects. */
复制代码
8 A" u0 R  L9 B  u3 N1 ^& ^$ G

7 K' L+ L% Q2 [5 r. n9 Z8 [. U* _" Z7 G7 L9 p$ p
thread对象:
8 P7 E+ M9 J! B& Z& ?4 P4 N8 u7 p  F7 w' l6 t0 r9 C
  1. struct rt_thread$ c4 D) u: `8 H
  2. {
    ' o! u8 _; k9 W0 d$ w
  3.     /* rt object */* B  N6 f' X! o$ _6 h1 M6 `
  4.     char        name[RT_NAME_MAX];                      /**< the name of thread */% M: H* D/ `. L! d! ]
  5.     rt_uint8_t  type;                                   /**< type of object */
    ) g* H: Z2 |7 H2 O. \
  6.     rt_uint8_t  flags;                                  /**< thread's flags */% G0 [9 i8 H/ K2 c
  7. 0 L" U# T: n) ?, B8 k
  8. #ifdef RT_USING_MODULE
    ' l( r, E% W9 Q+ O  C
  9.     void       *module_id;                              /**< id of application module */! o) V$ d% b0 q1 E- q: v" w
  10. #endif
    * f1 |( W# I9 |4 |$ z$ d! a

  11. $ |( @* O& U& x- x  g
  12.     rt_list_t   list;                                   /**< the object list */
    & Q  e! _) t1 `) S
  13.     rt_list_t   tlist;                                  /**< the thread list */$ C: I2 d$ Z2 n7 C' R

  14. 4 S! w9 e$ _# S: B+ R
  15.     /* stack point and entry */
    7 a' o) z6 U" H! K% u- P
  16.     void       *sp;                                     /**< stack point */! ^$ P' O" L5 u  W
  17.     void       *entry;                                  /**< entry */
    0 |, x& X/ E* U! S
  18.     void       *parameter;                              /**< parameter */2 ?$ ?! z. T- e; c! c  `% a* Z
  19.     void       *stack_addr;                             /**< stack address */
    ! D9 V$ q  d* O9 l& Z0 p
  20.     rt_uint32_t stack_size;                             /**< stack size */) `- s5 V) p/ c3 V

  21. + H3 @7 Y& [( V4 R
  22.     /* error code */
    " L- Q( G7 J. J+ j
  23.     rt_err_t    error;                                  /**< error code */
    % w* X! J0 B: ]" K9 Y7 P

  24. # d& ~/ k7 f6 S/ j/ p$ t, z& }" i
  25.     rt_uint8_t  stat;                                   /**< thread status */
    ) p$ S: v+ _5 s. X4 e) G

  26. ' l9 ]: ?$ V; B9 j
  27.     /* priority */: M2 u  T. l& [' b0 d) Z, Y
  28.     rt_uint8_t  current_priority;                       /**< current priority */
    " O* n5 u/ l$ |, t; O
  29.     rt_uint8_t  init_priority;                          /**< initialized priority */" @+ W0 c4 p% t- v+ s; e
  30. #if RT_THREAD_PRIORITY_MAX > 32& y) ^* c* R0 G
  31.     rt_uint8_t  number;
    . L, {* r/ q6 D0 s- P) y
  32.     rt_uint8_t  high_mask;) z. T1 k8 X7 P$ P: \0 q! w9 _
  33. #endif2 p, ^2 B' ~1 g. k/ a
  34.     rt_uint32_t number_mask;
    1 q5 M" D; d7 z, t% V

  35. 6 A1 m5 Z3 M  G9 F$ |& I/ A7 U3 J7 v
  36. #if defined(RT_USING_EVENT)* f0 E7 E$ c6 d6 O* a9 N
  37.     /* thread event */
    3 v% k/ I' R1 Q* B+ E! s
  38.     rt_uint32_t event_set;
    # q4 `  {# N1 ?' |7 K  b: \8 [
  39.     rt_uint8_t  event_info;
    ! |) V; N5 ~: H
  40. #endif, r0 v& T& D6 U% T) |, h

  41. 6 r. D* u, M1 n% F
  42. #if defined(RT_USING_SIGNALS)
    ! g" @8 E( E% X4 p, c5 j4 j0 ~
  43.     rt_sigset_t     sig_pending;                        /**< the pending signals */
    ! Q4 r- H7 _3 X. d
  44.     rt_sigset_t     sig_mask;                           /**< the mask bits of signal */
    - j$ B! Q$ T% n' I0 O
  45. - T' B+ `& `6 Z, V- i9 @
  46.     void            *sig_ret;                           /**< the return stack pointer from signal */
    # j& T- a  I7 H, q
  47.     rt_sighandler_t *sig_vectors;                       /**< vectors of signal handler */
    5 `+ b+ b5 Q+ ]6 c# ]% A  W  r
  48.     void            *si_list;                           /**< the signal infor list */
    . s% A8 n6 X9 Y! ~
  49. #endif; n& d+ q; ]- C/ j4 z4 J& V, Q; G
  50. + ~, T; H- N# ]) b( ^
  51.     rt_ubase_t  init_tick;                              /**< thread's initialized tick */$ t7 K8 b& ~: N  h& t
  52.     rt_ubase_t  remaining_tick;                         /**< remaining tick */
    * n' b0 b2 p- I9 V  ~
  53. " k# K( q3 e+ f" c) o$ X
  54.     struct rt_timer thread_timer;                       /**< built-in thread timer *// a  S( z9 o+ r7 S

  55. / \2 F' b2 q% {! H. L: }
  56.     void (*cleanup)(struct rt_thread *tid);             /**< cleanup function when thread exit */
    . B. e& o8 d9 o: w8 a

  57. * T& ~* U/ F* J) m( d  k7 Q
  58.     rt_uint32_t user_data;                              /**< private user data beyond this thread */3 o( J# q$ v! L  V2 `. r: _
  59. };
    , f5 a5 k  P! ^0 R
  60. typedef struct rt_thread *rt_thread_t;
复制代码
5 ~3 [- k# J2 R0 P3 p: _

! e2 V/ F; ?2 W: Y* ^) }2 |3 a- G7 ~4 h; Z$ n# @' \' t! M- ^* B
timer对象:2 w& ^  U9 V. W7 ?2 x* L7 _
  1. struct rt_timer
    . l7 N  }/ C0 j* m+ _$ `4 a2 M
  2. {
    8 W& S( @, b, k4 a8 ]
  3.     struct rt_object parent;                            /**< inherit from rt_object */
    . A# l! o) d" G! Z- Y

  4. ; y1 C( Y: U- S+ B; U9 z, t* j2 c* e
  5.     rt_list_t        row[RT_TIMER_SKIP_LIST_LEVEL];
    , f4 L+ |+ C' @8 d) j

  6. ) a, C. e7 |% f) E' O, |) \4 ]: [# E# A
  7.     void (*timeout_func)(void *parameter);              /**< timeout function */
    & ^) G* j% @6 g1 V5 i' x
  8.     void            *parameter;                         /**< timeout function's parameter */% F: [* y1 M- S, X0 Y3 u( _
  9. 1 `/ Y4 c' u% }( r7 s+ [
  10.     rt_tick_t        init_tick;                         /**< timer timeout tick */. R6 W! E- c5 e6 X, ]3 R
  11.     rt_tick_t        timeout_tick;                      /**< timeout tick */: s& @; i- H* e( u4 f% `
  12. };
    ; p/ k5 V3 H, q! n" u8 T" _
  13. typedef struct rt_timer *rt_timer_t;
    0 d9 f, z5 K7 T9 Y
复制代码

4 E2 P7 q" }4 P- G, s9 T' W8 ]! n6 Q
- l! v- s# q1 N, b+ I/ ?
使用道具 举报 显示全部楼层 回复
最新评论 | 正序浏览
显示全部楼层 |楼层直达:
发表于 2019-6-11 09:08:17 | 显示全部楼层
同问
使用道具 举报 回复
发表于 2019-6-11 09:33:18 | 显示全部楼层
感觉没啥太大区别
使用道具 举报 回复
发表于 2019-6-11 11:13:46 | 显示全部楼层
使用上区别倒是不大,只是既然这里比较特别,总是有一定的原因,看第一遍书的时候,我也没发现,看第二遍的时候,觉得有点奇怪,就想搞明白一点
使用道具 举报 回复
发表于 2019-6-12 15:37:31 | 显示全部楼层
历史原因。这样写其实是不好的,但是改了就会涉及到大量代码出现编译不过的情况 所以没法动它
使用道具 举报 回复
发表于 2019-6-12 15:41:25 | 显示全部楼层
这么做是为了可以直接thread->name,就是直接一级指针去访问object里面的成员。" ]8 |( [# |$ o4 R+ d

$ Y. y  j( L9 B/ J# p5 h, |& z( z其实把thread改成像timer对象那样,直接对object对象继承也是没问题的,只是.....这么做会导致不兼容很多地方的代码了,大量的工程会编译不过。
使用道具 举报 回复
发表于 2019-6-15 10:11:19 | 显示全部楼层
这样要注意的是,如果在object对象中加入一个成员, 相应地,也要在thread结构体中同步加入; 同样要注意的,如果在thread结构中要加入一个成员的话,千万不要插入到object对象对应的范围里去
使用道具 举报 回复
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|RT-Thread开发者社区  

© 2013-2017 上海睿赛德电子科技有限公司 沪ICP备13014002号-1

Powered by RT-Thread

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