This routine locks the Threads Library global mutex. If the
    global mutex is currently held by another thread when a thread
    calls this routine, the calling thread waits for the global mutex
    to become available and then locks it.

    The thread that has locked the global mutex becomes its current
    owner and remains the owner until the same thread has unlocked
    it. This routine returns with the global mutex in the locked
    state and with the current thread as the global mutex's current
    owner.

    Use the global mutex when calling a library package that is
    not designed to run in a multithreaded environment. Unless the
    documentation for a library function specifically states that it
    is thread-safe, assume that it is not compatible; in other words,
    assume it is nonreentrant.

    The global mutex is one lock. Any code that calls any function
    that is not known to be reentrant should use the same lock.
    This prevents problems resulting from dependencies among threads
    that call library functions and those functions' calling other
    functions, and so on.

    The global mutex is a recursive mutex. A thread that has locked
    the global mutex can relock it without deadlocking. The locking
    thread must call pthread_unlock_global_np() as many times as it
    called this routine, to allow another thread to lock the global
    mutex.