请教，为什么多个线程SP指针指向同一地址？

发布于 2013-01-18 09:06:33 浏览：2755 订阅该版

为什么静态创建多个线程，用list_thread()看SP指针指向同一地址？

finsh>>list_thread()
 thread  pri  status      sp     stack size max used   left tick  error
-------- ---- ------- ---------- ---------- ---------- ---------- ---
tidle    0x1f ready   0x00000058 0x00000100 0x00000058 0x0000001d 000
tshell   0x14 ready   0x000001a0 0x00000800 0x000001b0 0x00000009 000
print    0x19 suspend 0x00000090 0x00000200 0x00000090 0x00000005 000
time     0x18 ready   0x00000088 0x00000200 0x000000cc 0x00000005 -02
USE_IF   0x17 suspend 0x00000090 0x00000200 0x00000090 0x00000005 000
ALARM    0x16 suspend 0x00000090 0x00000100 0x00000090 0x00000005 000
encode2  0x13 suspend 0x00000078 0x00000200 0x00000078 0x00000005 000
encode1  0x12 suspend 0x00000078 0x00000200 0x00000078 0x00000002 000
key      0x15 ready   0x00000080 0x00000100 0x00000080 0x00000005 -02
fsk      0x11 suspend 0x00000090 0x00000100 0x00000090 0x00000004 000
	0, 0x00000000

部分代码：
static rt_uint8_t key_stack[ 256 ];
static struct rt_thread key_thread;

static rt_uint8_t USE_IF_stack[ 512 ];
static struct rt_thread USE_IF_thread;

static rt_uint8_t encode1_stack[ 512 ];
static struct rt_thread encode1_thread;

static rt_uint8_t encode2_stack[ 512 ];
static struct rt_thread encode2_thread;

static rt_uint8_t time_stack[ 512 ];
static struct rt_thread time_thread;

static rt_uint8_t alarm_stack[ 256 ];
static struct rt_thread alarm_thread;

static rt_uint8_t fsk_stack[ 256 ];
static struct rt_thread fsk_thread;

result = rt_thread_init(&fsk_thread,
		"fsk",
		fsk_thread_entry, RT_NULL,
		(rt_uint8_t*)&fsk_stack[0], sizeof(fsk_stack), 0x11, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&fsk_thread);
	}

result = rt_thread_init(&key_thread,
		"key",
		key_thread_entry, RT_NULL,
		(rt_uint8_t*)&key_stack[0], sizeof(key_stack), 0x15, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&key_thread);
	}

result = rt_thread_init(&encode1_thread,
		"encode1",
		encode1_thread_entry, RT_NULL,
		(rt_uint8_t*)&encode1_stack[0], sizeof(encode1_stack), 0x12, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&encode1_thread);
	}

result = rt_thread_init(&encode2_thread,
		"encode2",
		encode2_thread_entry, RT_NULL,
		(rt_uint8_t*)&encode2_stack[0], sizeof(encode2_stack), 0x13, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&encode2_thread);
	}

result = rt_thread_init(&alarm_thread,
		"ALARM",
		alarm_thread_entry, RT_NULL,
		(rt_uint8_t*)&alarm_stack[0], sizeof(alarm_stack), 0x16, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&alarm_thread);

}

result = rt_thread_init(&USE_IF_thread,
		"USE_IF",
		USE_IF_thread_entry, RT_NULL,
		(rt_uint8_t*)&USE_IF_stack[0], sizeof(USE_IF_stack), 0x17, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&USE_IF_thread);

}

result = rt_thread_init(&time_thread,
		"time",
		time_thread_entry, RT_NULL,
		(rt_uint8_t*)&time_stack[0], sizeof(time_stack), 0x18, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&time_thread);

}

result = rt_thread_init(&print_thread,
		"print",
		print_thread_entry, RT_NULL,
		(rt_uint8_t*)&print_stack[0], sizeof(print_stack), 0x19, 5);

if (result == RT_EOK)
	{
        rt_thread_startup(&print_thread);