同优先级的多个线程，需要主动出让CPU

发布于 2018-08-17 16:39:53 浏览：2082 订阅该版

* 本帖最后由 wj2893155 于 2018-8-20 14:03 编辑 *

大家好，小弟新人
今天移植了RTT，但遇到了一个问题，如题。特来求教

我创建了3个线程，配置相同的优先级和时间片，每个线程内都是循环打印。
结果只有1个现成会打印，其他两个线程没有打印。
然后我在每个线程里加上rt_thread_yield，3个线程才能全部运行。如果必须这样，那时间片的概念有什么价值？

感谢

粘贴上代码：

static void uart_thread_entry(void *param)
{
                int i = 0;
                while (1)
                {
                        printf("%d----%d <br>", (int)param, i++);
                        //rt_thread_yield();
                        //rt_thread_sleep(1);
                }
}
static void uart_thread_entry2(void *param)
{
                int i = 0;
                while (1)
                {
                        printf("%d----%d <br>", (int)param, i++);
                        //rt_thread_yield();
                        //rt_thread_sleep(1);
                }
}
static void uart_thread_entry3(void *param)
{
                int i = 0;
                while (1)
                {
                        printf("%d----%d <br>", (int)param, i++);
                        //rt_thread_yield();
                        //rt_thread_sleep(1);
                }
}

static struct rt_thread uart_thread;
static struct rt_thread uart_thread2;
static struct rt_thread uart_thread3;
static rt_uint8_t uart_stack[512];
static rt_uint8_t uart_stack2[512];
static rt_uint8_t uart_stack3[512];
static void application()
{
                rt_err_t result;
        
                /* init uart thread */
                //static struct rt_thread uart_thread;
    result = rt_thread_init(&uart_thread,
                            "uart",
                            uart_thread_entry,
                            (void *)1,
                            (rt_uint8_t*)&uart_stack[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
                                //uart_test(NULL);
                          rt_thread_startup(&uart_thread);
    }
                
                /* init uart thread */
                //static struct rt_thread uart_thread2;
    result = rt_thread_init(&uart_thread2,
                            "uart2",
                            uart_thread_entry2,
                            (void *)2,
                            (rt_uint8_t*)&uart_stack2[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
                                //uart_test(NULL);
                          rt_thread_startup(&uart_thread2);
    }
                
                /* init uart thread */
    result = rt_thread_init(&uart_thread3,
                            "uart3",
                            uart_thread_entry3,
                            (void *)3,
                            (rt_uint8_t*)&uart_stack3[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
                                //uart_test(NULL);
                          rt_thread_startup(&uart_thread3);
    }
                
                
}

5 个回答

alee 2018-08-17

这家伙很懒，什么也没写！

把你代码贴出来看看。我试过相同优先级线程，时间片轮询是可以的。下面是我实验用的示例。

#define THREAD_PRIORITY         25
#define THREAD_STACK_SIZE       512
#define THREAD_TIMESLICE        5

/* 指向线程控制块的指针 */
static rt_thread_t tid1 = RT_NULL;
static rt_thread_t tid2 = RT_NULL;
/* 线程 1 入口 */
static void thread1_entry(void* parameter)
{
    rt_uint32_t count = 0;

while (1)
    {
        /* 打印线程 1 的输出 */
        rt_kprintf("thread1: count = %d\n", count ++);
    }
}

/* 线程 2 入口 */
static void thread2_entry(void* parameter)
{
    rt_uint32_t count = 0;
    while (1)
    {
        /* 打印线程 2 的输出 */
        rt_kprintf("thread2: count = %d\n", count ++);
    }
}

/* 线程让出处理器示例的初始化 */
int thread_yield_init(void)
{
    /* 创建线程 1 */
    tid1 = rt_thread_create("thread",
                            thread1_entry,      /* 线程入口是 thread1_entry */
                            RT_NULL,            /* 入口参数是 RT_NULL */
                            THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
    if (tid1 != RT_NULL)
        rt_thread_startup(tid1);

/* 创建线程 2 */
    tid2 = rt_thread_create("thread",
                            thread2_entry,      /* 线程入口是 thread2_entry */
                            RT_NULL,            /* 入口参数是 RT_NULL */
                            THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
    if (tid2 != RT_NULL)
        rt_thread_startup(tid2);

return 0;
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(thread_yield_init, thread yield);

下面是打印信息：
msh >thread1: count = 0
thread1: count = 1
thread1: thread2: count = 0
thread2: count = 1
thread2: count = 2count = 2
thread1: count = 3
thread1: count = 4
thread
thread2: count = 3
thread2: count = 4
thread2: count =1: count = 5
thread1: count = 6
thread1: count = 7
thre 8
thread2: count = 6
thread2: count = 7
thread2: counad2: count = 8
thread1: count = 9
thread1: count = 10
tt = 11thread2: count = 9
thread2: count = 10

wj2893155 2018-08-17

这家伙很懒，什么也没写！

static void uart_thread_entry(void *param)
{
		int i = 0;
		while (1)
		{
			printf("%d----%d\r\n", (int)param, i++);
			//rt_thread_yield();
			//rt_thread_sleep(1);
		}
}
static void uart_thread_entry2(void *param)
{
		int i = 0;
		while (1)
		{
			printf("%d----%d\r\n", (int)param, i++);
			//rt_thread_yield();
			//rt_thread_sleep(1);
		}
}
static void uart_thread_entry3(void *param)
{
		int i = 0;
		while (1)
		{
			printf("%d----%d\r\n", (int)param, i++);
			//rt_thread_yield();
			//rt_thread_sleep(1);
		}
}

static struct rt_thread uart_thread;
static struct rt_thread uart_thread2;
static struct rt_thread uart_thread3;
static rt_uint8_t uart_stack[512];
static rt_uint8_t uart_stack2[512];
static rt_uint8_t uart_stack3[512];
static void application()
{
		rt_err_t result;
	
		/* init uart thread */
		//static struct rt_thread uart_thread;
    result = rt_thread_init(&uart_thread,
                            "uart",
                            uart_thread_entry,
                            (void *)1,
                            (rt_uint8_t*)&uart_stack[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
				//uart_test(NULL);
			  rt_thread_startup(&uart_thread);
    }
		
		/* init uart thread */
		//static struct rt_thread uart_thread2;
    result = rt_thread_init(&uart_thread2,
                            "uart2",
                            uart_thread_entry2,
                            (void *)2,
                            (rt_uint8_t*)&uart_stack2[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
				//uart_test(NULL);
			  rt_thread_startup(&uart_thread2);
    }
		
		/* init uart thread */
    result = rt_thread_init(&uart_thread3,
                            "uart3",
                            uart_thread_entry3,
                            (void *)3,
                            (rt_uint8_t*)&uart_stack3[0],
                            sizeof(uart_stack),
                            20,//0~32,32¸ß
                            5);
    if (result == RT_EOK)
    {
				//uart_test(NULL);
			  rt_thread_startup(&uart_thread3);
    }
		
		
}