RT-Thread-请教关于线程使用栈，会随着最大设置值也变化的问题~~RT-Thread问答社区

请教关于线程使用栈，会随着最大设置值也变化的问题~~

发布于 2014-06-16 13:05:57 浏览：2301 订阅该版

如题。。

现象是：
如果线程a最大栈空间设置为1024[0x400]，系统启动后list_thread()，会看到线程a最大使用[0x354]；
如果线程a最大栈空间设置为2048[0x800]，系统启动后list_thread()，会看到线程a最大使用[0x754]；
如果线程a最大栈空间设置为4096[0x1000]，系统启动后list_thread()，会看到线程a最大使用[0xF54]；
都是剩余了0xAC字节； [s:169]  [s:169]

在想应该是线程入口函数的问题，但是也没发现什么问题，请教有此经历的指导一下~

以下是线程入口函数，调用的函数请查看注释：
```
//************************TCP客户端接收管理线程_入口函数******************************//
static rt_uint8_t tcp_rx_stack[ 1024 ];
static struct rt_thread tcp_rx_thread;
void tcp_rx_thread_entry(void*parameter) 
{ 
    rt_int16_t sock, recvlen=0;
    extern rt_uint8_t	rj45_state;

while(1)
	{														
		if (rj45_state == 0)		//如果网线没有连接
		{	 
			if(sock_tcp_alive_check()==1)	//查询alive全局变量，有互斥
			{
				sock_tcp_close();                 //关闭sock，有互斥
				if(printf_eth_tcp_sock)	/*这是个调试开关*/
				{rt_kprintf("tcp_rx_thread_entry{rj45_state == 0}: close sock!
");}			
			}																 
		}
		if(sock_tcp_alive_check()==0)	//如果不在线，有互斥
		{
			/* if disconnect, try connect again. */
			rt_thread_delay(RT_TICK_PER_SECOND);		 //如果不在线，1s后再次查看是否在线。。。。
			if (sock_tcp_alive_check()==0)   //如果不在线，有互斥
			{
				sock = 	tcp_client_socket_config((char *)server_config.ip,server_config.port );  //尝试连接TCP服务器
				sock_tcp_set(sock);			//设置alive全局变量，有互斥
				sock_tcp_alive_check();		//更新alive全局变量，有互斥
				if(printf_eth_tcp_sock)	/*这是个调试开关*/
				{}
			}			
		}		 	
		else //如果在线
		{
			recvlen	= blocking_lwip_recv(tcp_client_sock, tcp_recv_buf , MAX_TCP_RBUF-1 , RECV_TIMEOUT); //非阻塞式接收函数，内部调用了lwip_select（）设置sock非阻塞接收

////////////////TCP连接出错
			if (recvlen < 0) //recvlen 标志-1 说明网线断开  0 未接收到数据 >0 接收的数据长度
			{	  
				sock_tcp_close();        //关闭sock，有互斥
				rt_kprintf("tcp_rx_thread_entry{recvlen<0}: close sock!
");
				if(printf_eth_tcp_sock)	/*这是个调试开关*/
				{}
			}
////////////////TCP没有数据		
			if (recvlen == 0) 
			{
				continue;
			}
////////////////TCP收到数据						
			if (recvlen > 0)
			{
				if(printf_eth_tcp_rx)/*这是个调试开关*/
				{rt_kprintf("tcp_rx_thread_entry: recvlen: = %d 
", recvlen);}	// 打印收取的数据长度	
				processing_lwip_recv(recvlen);	  //正在处理收取的数据,此函数大约耗费512byte栈。应该跟这里没关系，因为尝试屏蔽掉这个函数依旧如此
			}	
		}
	}		
} ```

以下是sock相关函数：
```
//关闭sock函数_互斥量tcp_sock_mutex
int 
sock_tcp_close(void)
{

rt_mutex_take(&tcp_sock_mutex, RT_WAITING_FOREVER);
/**************************互斥临界区_开始****************************/
	if (tcp_client_sock != -1) 
	{
		lwip_close(tcp_client_sock);		//关闭sock连接
		tcp_client_sock = -1;		 	//tcp_client_sock赋值为-1
		alive_flag = 0;				//在线标志置零
		rt_hw_led_off(2);				//关闭在线灯
	}
/**************************互斥临界区_结束****************************/
	rt_mutex_release(&tcp_sock_mutex);

return 0;
}

//设置sock函数_互斥量tcp_sock_mutex
int 
sock_tcp_set(int sock)
{

rt_mutex_take(&tcp_sock_mutex, RT_WAITING_FOREVER);
/**************************互斥临界区_开始****************************/
	tcp_client_sock = sock;			//设置sock状态
/**************************互斥临界区_结束****************************/
	rt_mutex_release(&tcp_sock_mutex);

if (sock >= 0) 
	{
		rt_hw_led_on(2);					//开启在线灯
		rt_sem_release(ð_heart_sem);		//立刻上报一次tcp_heart	 
	}
	else
	{
		rt_hw_led_off(2);					//关闭在线灯
	}

return 0;
}

//查询sock函数_互斥量tcp_sock_mutex
int sock_tcp_alive_check(void)
{
	int  alive = 0;

rt_mutex_take(&tcp_sock_mutex, RT_WAITING_FOREVER);
/**************************互斥临界区_开始****************************/
	alive = (tcp_client_sock < 0) ? 0 : 1;
	alive_flag = alive;
/**************************互斥临界区_结束****************************/
	rt_mutex_release(&tcp_sock_mutex);
	
	return alive;

}

//*************************TCP客户端创建和配置_被tcp_rx线程调用****************************//
int tcp_client_socket_config(char* url, int port)
{
	int sock = -1;
	int optval = 1;
	struct hostent *host;
	struct sockaddr_in s_addr;
	
	socklen_t  flag;

if ((NULL == url) || (port < 1000)) 
	{
		if(printf_eth_tcp_sock)	/*这是个调试开关_默认开启*/
		{rt_kprintf("TCP_ERROR:tcp_client_socket_config()- server_ip or port is error!
");}
		
		return -1;
	}
	
	host = gethostbyname(url);			// 通过函数入口参数url获得host地址（如果是域名，会做域名解析
	   
	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		lwip_close(sock);

if(printf_eth_tcp_sock)	/*这是个调试开关_默认开启*/
		{rt_kprintf("TCP_ERROR:tcp_client_socket_config()-> create socket error!
");}
		
		return -2;
	}

/*关闭Nagle算法，无延时*/
	flag = 1; 
	lwip_setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag) ); 	
	/*开启KEEPALIVE连接保活功能,时间见宏定义*/
	lwip_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));

/* 初始化预连接的服务端地址 */
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(port);
	s_addr.sin_addr = *((struct in_addr *)host->h_addr);

rt_memset(&(s_addr.sin_zero), 0, sizeof(s_addr.sin_zero));
	
	 /* 连接到服务端 */
	if (lwip_connect(sock, (struct sockaddr *)&s_addr, sizeof(struct sockaddr)) < 0) 	   //ANDY优化：此处期待非阻塞
	{
		/* close socket */
		lwip_close(sock);	  
		if(printf_eth_tcp_sock)	/*这是个调试开关_默认开启*/
		{rt_kprintf("tcp_client_socket_config()-> connect to tcp_server error(socket=[%d])!
",sock);}
		
		return -3;
	}

rt_mutex_take(&tcp_sock_mutex, RT_WAITING_FOREVER);
/**************************互斥临界区_开始****************************/
	alive_flag = 1;					//在线标志置1
/**************************互斥临界区_结束****************************/
	rt_mutex_release(&tcp_sock_mutex);

if(printf_eth_tcp_sock)	 /*这是个调试开关_默认开启*/
	{rt_kprintf("tcp_client_socket_config()-> connect to tcp_server success!
");}
	
	return sock;
}

//************************TCP客户端非阻塞式接收_被tcp_rx线程调用*****************************//
int blocking_lwip_recv(int s, void *mem, size_t len, int timeout)
{
    int readlen, offset = 0;
    fd_set fds;
    int ret;
    struct timeval to;

to.tv_sec = timeout/1000;
    to.tv_usec = (timeout%1000)*1000;

while (1) 
	{
        FD_ZERO(&fds);
        FD_SET(s, &fds);
        ret = lwip_select(s + 1, &fds, 0, 0, &to);
        if ( 0 == ret ) 				//描述符都没有准备好
		{
			break;
		}
        else if (ret < 0)  				//描述符出错了
		{
			if(printf_eth_tcp_sock)	 /*这是个调试开关*/
			{rt_kprintf("TCP_ERROR: blocking_lwip_recv()->lwip_select()-> ret<0(tcp_error)
");} 
				   
			return ret;
		}
	
        readlen = lwip_recvfrom(s, ((char*)mem)+offset, len-offset, 0, NULL, NULL);
        if (0 == readlen) 
		{
            return -1;
		}
        else if (readlen < 0) 			//收取数据失败
		{           
			if(printf_eth_tcp_sock)	 /*这是个调试开关*/
			{
				rt_kprintf("TCP_ERROR: blocking_lwip_recv()->lwip_recvfrom()-> readlen<0(tcp_error)
",readlen);
				list_date();		//打印时间
			}	   
			
			return readlen;		
		}
        if (readlen == (len-offset)) 
		{
            offset = len;
            break;
        }
        offset += readlen;		
    }
    return offset;
}

```