Mutexes and Blocking

Why is it run I run the following thread code my mutex doesn't cause other incoming threads to block until the current one has finished?

Code:

---

void *runner( void *arg) {
        int sleepTime =0;
        int get_return=-999;        /*Return value for the myHTTPserverGet function*/
        int server_return=-999;        /*Return value for the myHTTPserverResponse function*/
        int rc;


        struct parm *p = (void *) arg;
       
        if( (rc = pthread_mutex_lock(&mutex)) != 0) {
                fprintf(stderr, "Error locking the mutex\n");
                fprintf(stderr, "ERRNO Value: %s\n", strerror(errno));
                exit(1);
        }

        //Get the client's request
        if((get_return = myHTTPserverGet(p->socket, p->path, p->from, p->userAgent, &sleepTime)) < 0) {
                    fprintf(stdout, "Trouble in myHTTPserverGet.\nReturn Value = %d\n", get_return);
              exit(1);
        }

        sleep(sleepTime);                               

        //Respond to the Client
        if((server_return =myHTTPserverResponse(p->socket, p->userAgent, get_return, p->path, sleepTime)) < 0) {
                fprintf(stdout, "Trouble in myHTTPserverResponse.\nReturn Value = %d\n", server_return);
                exit(1);
        }

        if( (rc = pthread_mutex_unlock(&mutex)) != 0) {
                fprintf(stderr, "Error locking the mutex\n");
                fprintf(stderr, "ERRNO Value: %s\n", strerror(errno));
                exit(1);
        }

        myTCPclose(p->socket);

        thread_count--;       
        pthread_exit(0);
}

---

What happens what you don't expect? It does look fine to me... What makes you think it doesn't work?

Did you initialise the mutex?

I have a client/server program which I would like to read in a client's request and then create a thread for each request that goes through and processes each accordingly. But my issue is that when I run a request and have it sleep for 5 seconds and then have another request come in after this with no sleep time. Should it not be blocked until the '5 second' thread is finished executing before it can execute this code? Here is the rest of the main in case you would like to see that also.

Code:

---

#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
#include "http.h"
#include "myTCP.h"

void *runner( void * ptr);

struct parm{
        int socket;
        char path[100];
        char *from;
        char *userAgent;
};

int thread_count=0; //Current amount of threads operating
int read_count=0;
int write_count=0;

pthread_mutex_t    mutex;
pthread_mutexattr_t    attr;


int main(int argc, char *argv[]) {
        int        port=-999;                /* port number to connect to, on server */
        int        msock=-999;                /* socket descriptor for connection */
        int  iRet; //Return value for pthread_create
        int  pid; //process id
        int MAX_THREAD=-999; //Maximum amount of threads allowed to run

        char *server_full_message = "HTTP/1.0 502 Server temporarily overloaded\n\n502 SERVER TEMPORARILY OVERLOADED\n";
 
        struct parm *p;

//        p=(parm *)malloc(sizeof(parm)*n); //Use this when you have a thread pool
        p=(struct parm *)malloc(sizeof(struct parm)); //Allocate space for the p structure

        pid = getpid();
        if(argc==1) {
                p->userAgent = argv[0];
                port = WL_PORT;       
                MAX_THREAD = 5;
        } else if(argc==2) {
                p->userAgent = argv[0];
                MAX_THREAD = atoi(argv[1]);
                port = WL_PORT;
        } else if (argc==3) {
                p->userAgent = argv[0];
                MAX_THREAD = atoi(argv[1]);
                if(atoi(argv[2]) >1024) port = atoi(argv[2]);
                else port = WL_PORT;
        } else {
                fprintf(stderr,"ERROR: useage:  <%s> <path> [<Max # Threads>] [<Port>]\n", argv[0]);
                exit(1);
        }
        #ifdef DEBUG
                fprintf(stderr,"DEBUG: %d %s will listen on port %d\n", pid, argv[0], port);
                fprintf(stderr,"DEBUG: MAX_THREAD = %d\n", MAX_THREAD);
        #endif

        pthread_t aThread; //Thread to be executed

      msock = myTCPserverSocket(port, argv[0]);


 
// Now accept connections and service clients forever,

        while(1) {
                /*Accept the client's socket*/
              p->socket = myTCPaccept(msock, argv[0]);

                if(thread_count <= MAX_THREAD) {
                        pthread_mutex_init(&mutex, &attr);
                        iRet = pthread_create(&aThread, NULL, runner, (void *) p);
                        thread_count++;
//                        pthread_join(aThread, NULL);
                }
                else { //The server is currently operating with the maximum number of threads
                        fprintf(stdout, "Successfully Received Messsage From Client\n");
               
                        //Respond to the Client notifying them that the server was too busy
                        write(p->socket, server_full_message, strlen(server_full_message));

                        fprintf(stdout, "Successfully Responded To Client\n");
                        myTCPclose(p->socket);
                }
        }
}

---