a threadpool by c

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
#include <pthread.h>

#define FALSE 0

pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t task_mutex = PTHREAD_MUTEX_INITIALIZER;
struct temp
{
        int name;
};

#define STACK_TYPE struct temp*

typedef struct STACK_NODE
{
        STACK_TYPE value;
        struct STACK_NODE *next;
} StackNode;

static StackNode *stack;
static int task_num = 0;
/**
 * create_stack
 */
void
create_stack( size_t size )
{

}

/**
 * Push
 */
void
push( int value )
{
        pthread_mutex_lock( &thread_mutex );

        StackNode *new_node;

        new_node = malloc( sizeof( StackNode ) );
        assert( new_node != NULL );
        new_node->value = malloc( sizeof( struct temp ) );
        assert( new_node->value != NULL );
        (new_node->value)->name = value;
        new_node->next = stack;
        stack = new_node;

        pthread_mutex_unlock( &thread_mutex );
}

/**
 * is_empty
 */
int
is_empty( void )
{
        return stack == NULL;
}

/**
 * Pop
 */
void
pop( void )
{
        pthread_mutex_lock( &thread_mutex );

        StackNode *first_node;

        assert( !is_empty() );
        first_node = stack;
        stack = first_node->next;
        free( first_node );

        //printf( "task_num is %d\n", task_num );
        pthread_mutex_unlock( &thread_mutex );
}


/**
 * top
 */
int
top( void )
{
        //assert( !is_empty() );
        pthread_mutex_lock( &thread_mutex );
        assert( !is_empty() );
        int name = stack->value->name;
        pthread_mutex_unlock( &thread_mutex );
        return name;


}

/**
 * is_full
 */
int
is_full( void )
{
        return FALSE;
}


/**
 * destroy_stack
 */
void
destory( void )
{
        pthread_mutex_lock( &thread_mutex );

        while( !is_empty() )
                pop();

        pthread_mutex_unlock( &thread_mutex );
}


int
get_task()
{
        pthread_mutex_lock( &task_mutex );
        int num = task_num;
        pthread_mutex_unlock( &task_mutex );
        return  num;
}

void
delete_task()
{
        pthread_mutex_lock( &task_mutex );
        task_num--;
        pthread_mutex_unlock( &task_mutex );
}


void*
thread_handle( void* arg )
{
        int name;
        while( get_task() != 0 )
        {
                name = top();
                //printf( "thread id is %uld and value is %d\n", pthread_self(), name );
                pop();
                delete_task();
                printf( "thread id is %uld and value is %d\n", pthread_self(), name );

        }

}


int
main( int argc, char** argv )
{
        int i = 0;

        if ( argc != 3 )
        {
                printf( "./t20 n m\n" );
                exit( 1 );
        }

        int n_thread = atoi( argv[1] );
        int n_task = atoi( argv[2] );
        task_num = n_task;

        for ( ; i < n_task; i++ )
                push( i );

        pthread_t *t;
        t = malloc( sizeof( pthread_t ) * n_thread );
        assert( t != NULL );

        for ( i = 0; i < n_thread; i++ )
        {
                pthread_create( (t + i), NULL, thread_handle, NULL );
                //pthread_join( *(t + i), NULL );
        }

        for ( i = 0; i < n_thread; i++ )
        {
                pthread_join( *(t + i), NULL );
        }

        free( t );
        exit( 0 );
}