pthread_mutex_lock 100% cpu?

código:

local void* s_accept_connections(tmpsock) void* tmpsock; { int32_t newfd; int32_t tmp; SOCKADDR_IN newsockaddr; pthread_t id; Connection* newconn; const char *s; char **splited; int i; StringVec *p; StringVec* next; Socket* sock; tmp = sizeof(newsockaddr); p = NULL; next = NULL; sock = (Socket *)tmpsock; if (!sock) return 0; while (true){ newfd = accept(sock->fd,(SOCKADDR *)&newsockaddr,&tmp); if (newfd fd = newfd; newconn->addr = newsockaddr; s = (const char *)inet_ntoa(newsockaddr.sin_addr); p = split_string(s,"."); if (p != NULL){ splited = (char **)MyMalloc(sizeof(*splited) + 12); i = 0; for (; p != NULL; p = next){ if (p && p->next){ next = p->next; }else{ break; } splited[i] = p->value; i++; } newconn->ip = swap_uint32_t((uint32_t)(atoi(splited[0])) + (atoi(splited[1]) << 8) + (atoi(splited[2]) << 16) + (atoi(splited[3]) <ip = 0; } newconn->closed = false; newconn->state = 0; newconn->state |= S_NEED_LOGIN; pthread_mutex_init(&g_ping_mutex,NULL); pthread_cond_init(&g_ping_cond,NULL); pthread_create(&id,NULL,s_ping_thread,(void *)newconn); a_conn(&sock->conn,newconn); #ifndef NDEBUG _("Accepting connection...\n"); #endif if (sock->has_callback){ sock->func(newconn); #ifndef NDEBUG _("Accepted connection\n"); #endif } } } return 0; } void start_accept(sock,join) Socket* sock; bool join; { pthread_t id; pthread_attr_t attr; if (!sock) return; if (!sock->conn){ sock->conn = (Connection *)MyMalloc(sizeof(*sock->conn)); if (!sock->conn) return; } set_nonblocking(sock->fd); set_nonblocking(sock->conn->fd); pthread_attr_init(&attr); pthread_mutex_init(&g_socket_mutex,NULL); if (join){ pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE); }else{ pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED); } pthread_create(&id,&attr,s_accept_connections,sock); if (join){ pthread_join(id,NULL); pthread_attr_destroy(&attr); pthread_mutex_destroy(&g_socket_mutex); } } 

Simplemente da 100% CPU, ¿alguna idea? Si se necesita más código, publicaré mal

¿Qué te hace creer que pthread_mutex_lock() es responsable del uso de la CPU?

Use un depurador para averiguar lo que está sucediendo. Mi conjetura es que hay algo mal con su socket, haciendo que su llamada accept() no se bloquee.

Verifique el valor / mensaje de retorno (con perror() si está ejecutando Linux).

EDITAR:

Necesitas saber qué parte del código está formando un bucle, un depurador puede ayudarte a encontrar esto.

Tiene un bucle de while(true) que es muy probable que sea responsable del bucle enless y del uso del 100% de la CPU. Debería estar bien, ya que tiene una llamada para aceptar () (aquí: newfd = accept(sock->fd,(SOCKADDR *)&newsockaddr,&tmp); ) que se supone que debe detener el proceso / proceso hasta la próxima conexión del cliente. Pero si su socket no está correctamente inicializado, accept() puede devolver un error sin esperar.