Q:

An error when i acces concurrently to pthread_mutex_t pthread_mutex_lock.c:62: __pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed

Why i received this error? 
This program i was made to reproduce an error that i received in other programs. 
The only task of this progran is lock and unlock concurrently pthread_mutex_t
#include <pthread.h>
#include <stdio.h>
#include <stdbool.h>

#ifndef TREADSXXX
#define TREADSXXX 100
#endif

#ifndef TREADSXXX_TO_UNLOCK
#define TREADSXXX_TO_UNLOCK 25
#endif

#ifndef TREADSXXX_TO_LOCK
#define TREADSXXX_TO_LOCK 4
#endif

#ifndef SEEDXXX
#define SEEDXXX 0
#endif

void *threadF(void *nada);

pthread_mutex_t stop[TREADSXXX];

pthread_mutex_t numberAsignation;

pthread_mutex_t waintNumberAsignation;

pthread_t idTread[TREADSXXX];

unsigned int counterT=0;

int main(void){
    unsigned int localCounter;
    srand(SEEDXXX);
    pthread_mutex_init(&numberAsignation, NULL);
    pthread_mutex_init(&waintNumberAsignation, NULL);
    for(localCounter=0; localCounter<TREADSXXX; localCounter++)
        pthread_mutex_init(stop+localCounter, NULL);
    pthread_mutex_lock(&waintNumberAsignation);
    for(localCounter=0; localCounter<TREADSXXX; localCounter++)
        pthread_create(idTread+localCounter, NULL, threadF, NULL);
    while(getchar()!='X');
}

void *threadF(void *nada){
    unsigned int nunmber, localCounter, aux;
    pthread_mutex_lock(&numberAsignation);
    nunmber=counterT;
    counterT++;
    pthread_mutex_unlock(&numberAsignation);
    if(nunmber<TREADSXXX-1)
        pthread_mutex_lock(&waintNumberAsignation);
        pthread_mutex_unlock(&waintNumberAsignation);
    while(true){
        for(localCounter=0; localCounter<TREADSXXX_TO_UNLOCK; localCounter++){
            pthread_mutex_unlock(stop+(rand()%TREADSXXX));
        }
        for(localCounter=0; localCounter<TREADSXXX_TO_LOCK; localCounter++){
            pthread_mutex_lock(stop+(rand()%TREADSXXX));
        }
    }
}

--------------------#####--------------------
This is the other program
This program simulates the dining philosophers problem. 
// Este programa es propenso al siguiente error: pthread_mutex_lock.c:62: __pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed. 

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

// Prototipo de la función que va a ejecutar los thread hijos
void *filosofo (void *nada);

//Cantidad de filosofos
#define FILOSOFOS 5

#define CONDICIONITERACION(X) ((X<1000000))

#define MAX_VENTAJA 2

// mutex que representan los tenedores
pthread_mutex_t tenerdor[FILOSOFOS];

// mutex para evitar corrupcion en la salida por pantalla
pthread_mutex_t pantalla;

// mutex que permite comprobar la cantidad de comensales
pthread_mutex_t pt_m_tComensales;

// mutex que no deja comer al filosofo
pthread_mutex_t pt_m_tEsperar;

// mutex para asignarle numero al filosofo
// deberia hacerlo pasandole un parametro a la funcion hija pero no se como
pthread_mutex_t pt_mNumeroF;

pthread_mutex_t diferenciaIteraciones;

pthread_mutex_t ventajaInjusta[FILOSOFOS];

struct acaparamiento{
    short iteraciones;
    bool bloqueado;
} seguiento[FILOSOFOS];

// Guarda en un arreglo char el estado de los tenedores
char estadoTenedores[FILOSOFOS+1];

// Variable usada para asignarle numeros a los filosofos
int iContadorF=0;

// Lleva la cuenta del numero de comensales
int iComensales=0;

//
bool bEsperando=false;

// Principal
main()
{
    // Arreglo de identificadores de hilos
    pthread_t idHilo[FILOSOFOS];

    // error devuelto por la función de creación del thread
    int error;

    int contador;

    /* Se inicializan los mutex */
    pthread_mutex_init (&pantalla, NULL);
    pthread_mutex_init (&pt_mNumeroF, NULL);
    pthread_mutex_init (&diferenciaIteraciones, NULL);
    for(contador=0; contador<FILOSOFOS; contador++){
        pthread_mutex_init (tenerdor+contador, NULL);
        pthread_mutex_init (ventajaInjusta+contador, NULL);
    }

    // Se inicia el arreglo que contiene la info para mostrar por pantalla
    for(contador=0; contador<FILOSOFOS; contador++){
        // Se inicia el arreglo que contiene la info para mostrar por pantalla
        estadoTenedores[contador]='L'; 
        seguiento[contador].iteraciones=0;
        seguiento[contador].bloqueado=false;
    }
    estadoTenedores[FILOSOFOS]='\0';

    printf("\nRenglon: numero filosofo, actividad (C: Cojer, D: Dejar) tenedor, iteracion");
    printf("\nTenedores: L(libre) O(Ocupado) Q(Quiero)");

    printf("\ninicia:  %s", estadoTenedores);

    // Creamos los threads
    for(contador=0; contador<FILOSOFOS; contador++){
        error = pthread_create (idHilo+contador, NULL, filosofo, NULL);

        // Comprobamos el error al arrancar el thread
        if (error ! = 0)
        {
            perror ("No puedo crear thread");
            exit (-1);
        }
    }

    // Esperamos hasta que se digite X y se precione enter
    // El progama se detendra cuando suceda esto aunque los hilos esten activos
    while(getchar()!='X');
}

// Esta funcion se ejecuta concurrentemente
void *filosofo (void *nada)
{
    int contador, numeroFilosofo, contador2, menor;
    char ctemp1;

    //Le asignamos un puesto al filosofo
    pthread_mutex_lock (&pt_mNumeroF);
        numeroFilosofo=iContadorF;
        iContadorF++;
    pthread_mutex_unlock (&pt_mNumeroF);

    for(contador=0; CONDICIONITERACION(contador); contador++){

        // Se verifica que no tengamos mas de 4 comensales
        // En si hay 4 se bloquea al 5
        pthread_mutex_lock (&pt_m_tComensales);
            iComensales++;
            if(iComensales>=FILOSOFOS-1){
                pthread_mutex_lock (&pt_m_tEsperar);
            }
        pthread_mutex_unlock (&pt_m_tComensales);

            pthread_mutex_lock (&diferenciaIteraciones);
                seguiento[numeroFilosofo].iteraciones++;
                menor=seguiento[0].iteraciones;
                for(contador2=1; contador2<FILOSOFOS; contador2++){
                    if(seguiento[contador2].iteraciones<menor)
                        menor=seguiento[contador2].iteraciones;
                }
                for(contador2=0; contador2<FILOSOFOS; contador2++){
                    seguiento[contador2].iteraciones=seguiento[contador2].iteraciones-menor;
                    if(seguiento[contador2].iteraciones<MAX_VENTAJA && seguiento[contador2].bloqueado)
                        pthread_mutex_unlock (ventajaInjusta+contador2);
                }
                pthread_mutex_lock (&pantalla);
                    printf("\nFilosofo %d ciclo %d diferencia interaciones: ", numeroFilosofo, contador);
                    for(contador2=0; contador2<FILOSOFOS; contador2++){
                        seguiento[contador2].iteraciones;
                        printf("%d ", seguiento[contador2].iteraciones);
                    }
                pthread_mutex_unlock (&pantalla);
            pthread_mutex_unlock (&diferenciaIteraciones);

            // El filosofo toma el primer tenedor
            pthread_mutex_lock (tenerdor+numeroFilosofo);
                pthread_mutex_lock (&pantalla);
                    printf("\n%d C1 %d:  %s  ->  ", numeroFilosofo, contador, estadoTenedores);
                    estadoTenedores[numeroFilosofo]='O';
                    printf("%s;  ->  ", estadoTenedores);
                    ctemp1=estadoTenedores[(numeroFilosofo+1)%FILOSOFOS];
                    estadoTenedores[(numeroFilosofo+1)%FILOSOFOS]='Q';
                    printf("%s", estadoTenedores);
                    estadoTenedores[(numeroFilosofo+1)%FILOSOFOS]=ctemp1;
                pthread_mutex_unlock (&pantalla);

                // El filosofo toma el segundo tenedor
                pthread_mutex_lock (tenerdor+(numeroFilosofo+1)%FILOSOFOS);
                    pthread_mutex_lock (&pantalla);
                        printf("\n%d C2 %d:  %s  ->  ", numeroFilosofo, contador, estadoTenedores);
                        estadoTenedores[(numeroFilosofo+1)%FILOSOFOS]='O';
                        printf("%s", estadoTenedores);
                    pthread_mutex_unlock (&pantalla);

                // El filosofo deja el segundo tenedor
                pthread_mutex_unlock (tenerdor+(numeroFilosofo+1)%FILOSOFOS);
                pthread_mutex_lock (&pantalla);
                    printf("\n%d D2 %d:  %s  ->  ", numeroFilosofo, contador, estadoTenedores);
                    estadoTenedores[(numeroFilosofo+1)%FILOSOFOS]='L';
                    printf("%s", estadoTenedores);
                pthread_mutex_unlock (&pantalla);

            // El filosofo deja el primer tenedor
            pthread_mutex_unlock (tenerdor+numeroFilosofo);
            pthread_mutex_lock (&pantalla);
                printf("\n%d D1 %d:  %s  ->  ", numeroFilosofo, contador, estadoTenedores);
                estadoTenedores[numeroFilosofo]='L';
                printf("%s", estadoTenedores);
            pthread_mutex_unlock (&pantalla);

        // Si hay solo 3 comensales se desbloquea la entrada
        pthread_mutex_unlock (&pt_m_tEsperar);
        pthread_mutex_lock (&pt_m_tComensales);
            iComensales--;
        pthread_mutex_unlock (&pt_m_tComensales);

        pthread_mutex_lock (&diferenciaIteraciones);
            if(MAX_VENTAJA<=seguiento[numeroFilosofo].iteraciones){
                seguiento[numeroFilosofo].bloqueado=true;
                pthread_mutex_unlock (&diferenciaIteraciones);
                pthread_mutex_lock (ventajaInjusta+numeroFilosofo);
                pthread_mutex_lock (&diferenciaIteraciones);
            }
            seguiento[numeroFilosofo].bloqueado=false;
        pthread_mutex_unlock (&diferenciaIteraciones);
    }
}

A:

You can't release a mutex you don't hold. 
Your thread function calls pthread_mutex_unlock for a random mutex, which is probably not held by it. 
Lock and unlock must be done symmetrically.  Take a lock, do what you need, release it in the same thread.