您的位置：首页 > 运维架构 > Linux

Linux下线程的调度策略与优先级（一）

2010-08-25 15:56 513 查看

Linux内核的三种调度策略：

　　1，SCHED_OTHER 分时调度策略，

2，SCHED_FIFO实时调度策略，先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃

3，SCHED_RR实时调度策略，时间片轮转。当进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平

Linux线程优先级设置

首先，可以通过以下两个函数来获得线程可以设置的最高和最低优先级，函数中的策略即上述三种策略的宏定义：

　　int sched_get_priority_max(int policy);

　　int sched_get_priority_min(int policy);

　 SCHED_OTHER是不支持优先级使用的，而SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，数值越大优先级越高。

设置和获取优先级通过以下两个函数

int
pthread_attr_setschedparam
(
pthread_attr_t
*
attr,
const
struct
sched_param *
param)
;

　　int pthread_attr_getschedparam
(
const
pthread_attr_t
*
attr,
struct
sched_param *
param)
;

param.
sched_priority =
51;
//设置优先级

系统创建线程时，默认的线程是SCHED_OTHER。所以如果我们要改变线程的调度策略的话，可以通过下面的这个函数实现。

int
pthread_attr_setschedpolicy
(
pthread_attr_t
*
attr,
int
policy)
;

上面的param使用了下面的这个数据结构：

struct
sched_param

{

int
__sched_priority;
//所要设定的线程优先级

}
;

我们可以通过下面的测试程序来说明，我们自己使用的系统的支持的优先级：

#
include
<
stdio.
h>

#
include
<
pthread.
h>

#
include
<
sched.
h>

#
include
<
assert
.
h>

static
int
get_thread_policy(
pthread_attr_t
*
attr)

{

int
policy;

int
rs =
pthread_attr_getschedpolicy
(
attr,
&
policy)
;

assert
(
rs=
=
0)
;

switch
(
policy)

{

case
SCHED_FIFO:

printf
(
"policy= SCHED_FIFO/n"
)
;

break
;

case
SCHED_RR:

printf
(
"policy= SCHED_RR"
)
;

break
;

case
SCHED_OTHER:

printf
(
"policy=SCHED_OTHER/n"
)
;

break
;

default
:

printf
(
"policy=UNKNOWN/n"
)
;

break
;

}

return
policy;

}

static
void
show_thread_priority(
pthread_attr_t
*
attr,
int
policy)

{

int
priority =
sched_get_priority_max(
policy)
;

assert
(
priority!=-1)
;

printf
(
"max_priority=%d/n"
,
priority)
;

priority=
sched_get_priority_min(
policy)
;

assert
(
priority!=-1)
;

printf
(
"min_priority=%d/n"
,
priority)
;

}

static
int
get_thread_priority(
pthread_attr_t
*
attr)

{

struct
sched_param param;

int
rs =
pthread_attr_getschedparam
(
attr,
&
param)
;

assert
(
rs=
=
0)
;

printf
(
"priority=%d"
,
param.
__sched_priority)
;

return
param.
__sched_priority;

}

static
void
set_thread_policy(
pthread_attr_t
*
attr,
int
policy)

{

int
rs =
pthread_attr_setschedpolicy
(
attr,
policy)
;

assert
(
rs=
=
0)
;

get_thread_policy(
attr)
;

}

int
main(
void
)

{

pthread_attr_t
attr;

struct
sched_param sched;

int
rs;

rs =
pthread_attr_init
(
&
attr)
;

assert
(
rs=
=
0)
;

int
policy =
get_thread_policy(
&
attr)
;

printf
(
"Show current configuration of priority/n"
)
;

show_thread_priority(
&
attr,
policy)
;

printf
(
"show SCHED_FIFO of priority/n"
)
;

show_thread_priority(
&
attr,
SCHED_FIFO)
;

printf
(
"show SCHED_RR of priority/n"
)
;

show_thread_priority(
&
attr,
SCHED_RR)
;

printf
(
"show priority of current thread/n"
)
;

int
priority =
get_thread_priority(
&
attr)
;

printf
(
"Set thread policy/n"
)
;

printf
(
"set SCHED_FIFO policy/n"
)
;

set_thread_policy(
&
attr,
SCHED_FIFO)
;

printf
(
"set SCHED_RR policy/n"
)
;

set_thread_policy(
&
attr,
SCHED_RR)
;

printf
(
"Restore current policy/n"
)
;

set_thread_policy(
&
attr,
policy)
;

rs =
pthread_attr_destroy
(
&
attr)
;

assert
(
rs=
=
0)
;

return
0;

}

下面是测试程序的运行结果：

policy=
SCHED_OTHER

Show current configuration of priority

max_priority=
0

min_priority=
0

show SCHED_FIFO of priority

max_priority=
99

min_priority=
1

show SCHED_RR of priority

max_priority=
99

min_priority=
1

show priority of current thread

priority=
0Set thread policy

set
SCHED_FIFO policy

policy=
SCHED_FIFO

set
SCHED_RR policy

policy=
SCHED_RRRestore current policy

policy=
SCHED_OTHER

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航