Thread: what exactly does pthread_mutex_lock() ?

Hi,

I read some tutorials but couldn't figure out how mutexes really work.

consider this example from http://www.ibm.com/developerworks/library/l-posix2/

Code:

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;

void *thread_function(void *arg) {
  int i,j;
  for ( i=0; i<20; i++ ) {
    pthread_mutex_lock(&mymutex);
    j=myglobal;
    j=j+1;
    printf(".");
    fflush(stdout);
   sleep(1);
    myglobal=j;
    pthread_mutex_unlock(&mymutex);
  }
  return NULL;
}

int main(void) {

  pthread_t mythread;
  int i;

  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("error creating thread.");
    abort();
  }

  for ( i=0; i<20; i++) {
    pthread_mutex_lock(&mymutex);
    myglobal=myglobal+1;
    pthread_mutex_unlock(&mymutex);
    printf("o");
    fflush(stdout);
    sleep(1);
  }

  if ( pthread_join ( mythread, NULL ) ) {
    printf("error joining thread.");
    abort();
  }

  printf("\nmyglobal equals &#37;d\n",myglobal);

  exit(0);

}

does the mutex_lock pause all other threads until unlock() ?
and if so, does one ever need more than one mutexes in a programm?

Or does the mutex_lock prevent all other threads from reading/writing to a variable?
And if so, how is the mutex "connected" to the variable what shall be protected/locked?

Or does lock() something completely else?

Thank you for a short explanation!

A locked mutex prevents anybody else from locking the mutex. If any other thread tries to call pthread_mutex_lock() on an already-locked mutex, that thread blocks until the mutex is unlocked.

Thx brewbuck, think I got the concept. But how does a programmer 2 years later know that he should lock mutex X before accessing data Y?
Is proper documentation the only way? That sounds little insecure to me.