[modify] add SMP support. (#23)

* [modify] add SMP support.

en/event_sample.c

@@ -109,6 +109,10 @@ int event_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1); /* start thread #1 */
 
     /* initiate the thread #2 (statically) */
@@ -119,6 +123,10 @@ int event_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2); /* start thread #2 */
 
     return 0;

en/interrupt_sample.c

@@ -60,6 +60,10 @@ int interrupt_sample(void)
     thread = rt_thread_create("thread1", thread_entry, (void *)10,
                               THREAD_STACK_SIZE,
                               THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(thread, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (thread != RT_NULL)
         rt_thread_startup(thread); /* start thread #1 */
 
@@ -67,6 +71,10 @@ int interrupt_sample(void)
     thread = rt_thread_create("thread2", thread_entry, (void *)20,
                               THREAD_STACK_SIZE,
                               THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(thread, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (thread != RT_NULL)
         rt_thread_startup(thread); /* start thread #2 */
 

en/mailbox_sample.c

@@ -121,6 +121,10 @@ int mailbox_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1); /* start thread #1 */
 
     /*initiate thread #2 */
@@ -131,6 +135,10 @@ int mailbox_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2); /* start thread #2 */
 
     return 0;

en/memp_sample.c

@@ -80,6 +80,10 @@ int mempool_sample(void)
     tid1 = rt_thread_create("thread1", thread1_mp_alloc, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1); /* start thread #1 */
 
@@ -87,6 +91,10 @@ int mempool_sample(void)
     tid2 = rt_thread_create("thread2", thread2_mp_release, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid2 != RT_NULL)
         rt_thread_startup(tid2); /* start thread #2 */
 

en/msgq_sample.c

@@ -135,6 +135,10 @@ int msgq_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -144,6 +148,10 @@ int msgq_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

en/mutex_sample.c

@@ -90,6 +90,10 @@ int mutex_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -99,6 +103,10 @@ int mutex_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
     return 0;
 }

en/priority_inversion.c

@@ -118,6 +118,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
 
@@ -127,6 +131,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid2 != RT_NULL)
         rt_thread_startup(tid2);
 
@@ -136,6 +144,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid3, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid3 != RT_NULL)
         rt_thread_startup(tid3);
 

en/producer_consumer.c

@@ -110,6 +110,10 @@ int producer_consumer(void)
                                     producer_thread_entry, RT_NULL,
                                     THREAD_STACK_SIZE,
                                     THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(producer_tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (producer_tid != RT_NULL)
         rt_thread_startup(producer_tid);
 
@@ -118,6 +122,10 @@ int producer_consumer(void)
                                     consumer_thread_entry, RT_NULL,
                                     THREAD_STACK_SIZE,
                                     THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(consumer_tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (consumer_tid != RT_NULL)
         rt_thread_startup(consumer_tid);
 

en/scheduler_hook.c

@@ -59,6 +59,10 @@ int scheduler_hook(void)
                             thread_entry, (void *)1,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
 
@@ -66,6 +70,10 @@ int scheduler_hook(void)
                             thread_entry, (void *)2,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE - 5);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid2 != RT_NULL)
         rt_thread_startup(tid2);
     return 0;

en/semaphore_sample.c

@@ -98,6 +98,10 @@ int semaphore_sample()
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -107,6 +111,10 @@ int semaphore_sample()
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

en/thread_sample.c

@@ -70,7 +70,10 @@ int thread_sample(void)
                             thread1_entry, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
-
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     /* start thread #1 */
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
@@ -83,6 +86,10 @@ int thread_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2); /* start thread #2 */
 
     return 0;

en/timeslice_sample.c

@@ -54,6 +54,10 @@ int timeslice_sample(void)
                            thread_entry, (void *)1,
                            THREAD_STACK_SIZE,
                            THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid != RT_NULL)
         rt_thread_startup(tid); /* start thread #1 */
 
@@ -62,6 +66,10 @@ int timeslice_sample(void)
                            thread_entry, (void *)2,
                            THREAD_STACK_SIZE,
                            THREAD_PRIORITY, THREAD_TIMESLICE - 5);
+#ifdef RT_USING_SMP
+    /* Bind threads to the same core to avoid messy log output when multiple cores are enabled */
+    rt_thread_control(tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid != RT_NULL)
         rt_thread_startup(tid); /* start thread #2 */
 

zh/event_sample.c

@@ -95,6 +95,10 @@ int event_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -104,6 +108,10 @@ int event_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

zh/interrupt_sample.c

@@ -45,6 +45,10 @@ int interrupt_sample(void)
     thread = rt_thread_create("thread1", thread_entry, (void *)10,
                               THREAD_STACK_SIZE,
                               THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(thread, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (thread != RT_NULL)
         rt_thread_startup(thread);
 
@@ -52,6 +56,10 @@ int interrupt_sample(void)
     thread = rt_thread_create("thread2", thread_entry, (void *)20,
                               THREAD_STACK_SIZE,
                               THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(thread, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (thread != RT_NULL)
         rt_thread_startup(thread);
 

zh/mailbox_sample.c

@@ -111,6 +111,10 @@ int mailbox_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -120,6 +124,10 @@ int mailbox_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
     return 0;
 }

zh/mailbox_urgent_sample.c

@@ -111,6 +111,10 @@ int mailbox_urgent_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -120,6 +124,10 @@ int mailbox_urgent_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
     return 0;
 }

zh/memp_sample.c

@@ -76,6 +76,10 @@ int mempool_sample(void)
     tid1 = rt_thread_create("thread1", thread1_mp_alloc, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
 
@@ -83,6 +87,10 @@ int mempool_sample(void)
     tid2 = rt_thread_create("thread2", thread2_mp_release, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid2 != RT_NULL)
         rt_thread_startup(tid2);
 

zh/msgq_sample.c

@@ -128,6 +128,10 @@ int msgq_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -137,6 +141,10 @@ int msgq_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

zh/mutex_sample.c

@@ -85,6 +85,10 @@ int mutex_sample(void)
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -94,6 +98,10 @@ int mutex_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
     return 0;
 }

zh/priority_inversion.c

@@ -116,6 +116,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
 
@@ -125,6 +129,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid2 != RT_NULL)
         rt_thread_startup(tid2);
 
@@ -134,6 +142,10 @@ int pri_inversion(void)
                             RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid3, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid3 != RT_NULL)
         rt_thread_startup(tid3);
 

zh/producer_consumer.c

@@ -112,6 +112,10 @@ int producer_consumer(void)
                                     producer_thread_entry, RT_NULL,
                                     THREAD_STACK_SIZE,
                                     THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(producer_tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (producer_tid != RT_NULL)
         rt_thread_startup(producer_tid);
 
@@ -120,6 +124,10 @@ int producer_consumer(void)
                                     consumer_thread_entry, RT_NULL,
                                     THREAD_STACK_SIZE,
                                     THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(consumer_tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (consumer_tid != RT_NULL)
         rt_thread_startup(consumer_tid);
 

zh/semaphore_sample.c

@@ -94,6 +94,10 @@ int semaphore_sample()
                    &thread1_stack[0],
                    sizeof(thread1_stack),
                    THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread1);
 
     rt_thread_init(&thread2,
@@ -103,6 +107,10 @@ int semaphore_sample()
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

zh/thread_sample.c

@@ -63,7 +63,10 @@ int thread_sample(void)
                             thread1_entry, RT_NULL,
                             THREAD_STACK_SIZE,
                             THREAD_PRIORITY, THREAD_TIMESLICE);
-
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid1, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     /* 如果获得线程控制块，启动这个线程 */
     if (tid1 != RT_NULL)
         rt_thread_startup(tid1);
@@ -76,6 +79,10 @@ int thread_sample(void)
                    &thread2_stack[0],
                    sizeof(thread2_stack),
                    THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(&thread2, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     rt_thread_startup(&thread2);
 
     return 0;

zh/timeslice_sample.c

@@ -49,6 +49,10 @@ int timeslice_sample(void)
                            thread_entry, (void *)1,
                            THREAD_STACK_SIZE,
                            THREAD_PRIORITY, THREAD_TIMESLICE);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid != RT_NULL)
         rt_thread_startup(tid);
 
@@ -57,6 +61,10 @@ int timeslice_sample(void)
                            thread_entry, (void *)2,
                            THREAD_STACK_SIZE,
                            THREAD_PRIORITY, THREAD_TIMESLICE - 5);
+#ifdef RT_USING_SMP
+    /* 绑定线程到同一个核上，避免启用多核时的输出混乱 */
+    rt_thread_control(tid, RT_THREAD_CTRL_BIND_CPU, (void*)0);
+#endif
     if (tid != RT_NULL)
         rt_thread_startup(tid);