pthread_mutex_lock 100% процессор?

Question

код:

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 <0){
        if (check_error_async()){
            pthread_mutex_lock(&g_socket_mutex);
#ifdef _WIN32
            Sleep(1000);
#else
            sleep(1);
#endif
            pthread_mutex_unlock(&g_socket_mutex);
            continue;
        }
    }else{
        newconn = (Connection *)MyMalloc(sizeof(*newconn));
        newconn->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]) << 24));
                MyFree((char *)splited);
        }else{
            newconn->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);
      }
    }

Это просто дает 100% процессоров, есть идеи? если нужно больше кода, пишите плохо

Answer 1

С чего вы взяли, что pthread_mutex_lock() отвечает за использование процессора?

Используйте отладчик, чтобы узнать, что происходит. Я предполагаю, что с вашим сокетом что-то не так, и ваш accept() звонок не блокируется.

Проверьте возвращаемое значение / сообщение (с помощью perror(), если вы работаете в Linux).

РЕДАКТИРОВАТЬ:

Вам нужно знать, какой фрагмент кода зацикливается, отладчик может помочь вам найти это.

У вас есть цикл while(true), который, скорее всего, будет отвечать за цикл enless и 100% загрузку ЦП. Все должно быть в порядке, поскольку у вас есть вызов метода accept () (здесь: newfd = accept(sock->fd,(SOCKADDR *)&newsockaddr,&tmp);), который должен остановить поток / процесс до следующего соединения с клиентом. Но если ваш сокет инициализирован неправильно, accept() может вернуть ошибку без ожидания.