linux线程同步的互斥锁(mutex)到底怎么用的》？谢谢

互斥锁(mutex) 通过锁机制实现线程间的同步。

1、初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。

2、静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

3、动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr)

4、加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。

    int pthread_mutex_lock(pthread_mutex *mutex)

    int pthread_mutex_trylock(pthread_mutex_t *mutex)

    解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。

    int pthread_mutex_unlock(pthread_mutex_t *mutex)

    销毁锁。锁在是使用完成后，需要进行销毁以释放资源。

    int pthread_mutex_destroy(pthread_mutex *mutex)

    #include <cstdio>  

    #include <cstdlib>  

    #include <unistd.h>  

    #include <pthread.h>  

    #include "iostream"  

    using namespace std  

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER  

    int tmp  

    void* thread(void *arg)  

    {  

        cout << "thread id is " << pthread_self() << endl  

        pthread_mutex_lock(&mutex)  

        tmp = 12  

        cout << "Now a is " << tmp << endl  

        pthread_mutex_unlock(&mutex)  

        return NULL  

    }  

    int main()  

    {  

        pthread_t id  

        cout << "main thread id is " << pthread_self() << endl  

        tmp = 3  

        cout << "In main func tmp = " << tmp << endl  

        if (!pthread_create(&id, NULL, thread, NULL))  

        {  

            cout << "Create thread success!" << endl  

        }  

        else  

        {  

            cout << "Create thread failed!" << endl  

        }  

        pthread_join(id, NULL)  

        pthread_mutex_destroy(&mutex)  

        return 0  

    }  

    //编译：g++ -o thread testthread.cpp -lpthread

为了能够有效的控制多个进程之间的沟通过程，保证沟通过程的有序和和谐，OS必须提供一定的同步机制保证进程之间不会自说自话而是有效的协同工作。比如在 共享内存的通信方式中，两个或者多个进程都要对共享的内存进行数据写入，那么怎么才能保证一个进程在写入的过程中不被其它的进程打断，保证数据的完整性 呢？又怎么保证读取进程在读取数据的过程中数据不会变动，保证读取出的数据是完整有效的呢？

常用的同步方式有： 互斥锁、条件变量、读写锁、记录锁(文件锁)和信号灯.

互斥锁：

顾名思义，锁是用来锁住某种东西的，锁住之后只有有钥匙的人才能对锁住的东西拥有控制权(把锁砸了，把东西偷走的小偷不在我们的讨论范围了)。所谓互斥， 从字面上理解就是互相排斥。因此互斥锁从字面上理解就是一点进程拥有了这个锁，它将排斥其它所有的进程访问被锁住的东西，其它的进程如果需要锁就只能等待，等待拥有锁的进程把锁打开后才能继续运行。 在实现中，锁并不是与某个具体的变量进行关联，它本身是一个独立的对象。进(线)程在有需要的时候获得此对象，用完不需要时就释放掉。

互斥锁的主要特点是互斥锁的释放必须由上锁的进(线)程释放，如果拥有锁的进(线)程不释放，那么其它的进(线)程永远也没有机会获得所需要的互斥锁。

互斥锁主要用于线程之间的同步。

条件变量：

上文中提到，对于互斥锁而言，如果拥有锁的进(线)程不释放锁，其它进(线)程永远没机会获得锁，也就永远没有机会继续执行后续的逻辑。在实际环境下，一 个线程A需要改变一个共享变量X的值，为了保证在修改的过程中X不会被其它的线程修改，线程A必须首先获得对X的锁。现在假如A已经获得锁了，由于业务逻 辑的需要，只有当X的值小于0时，线程A才能执行后续的逻辑，于是线程A必须把互斥锁释放掉，然后继续“忙等”。如下面的伪代码所示：

1.// get x lock

2.while(x

多线程的效果就是同一时间各个线程都在执行。

加锁不是给线程上锁。

pthread_mutex_lock(&qlock)表示尝试去把qlock上锁，它会先判断qlock是否已经上锁，如果已经上锁这个线程就会停在这一步直到其他线程把锁解开。它才继续运行。

所以代码中要么是线程1先执行完后执行线程2，要么就是线程2先执行，再执行线程1.而线程3一开始就执行了。

互斥量mutex是用来给多线程之间的贡献资源上锁的。也就是同一个时间只允许一个线程去访问该资源（资源：比如对文件的写 *** 作）。

现在来回答楼主的问题：

不是只要在pthread_mutex_lock(&qlock)与pthread_mutex_unlock(&qlock)之间的代码执行，其他的都不能介入吗？

其他的都不能介入，不是整个进程只运行这一个线程，其他线程都停住了。

“不能介入“这个动作需要程序员自己设计来保证：好比前面提到的文件读写 *** 作。为了防止多个线程同时对文件进行写入 *** 作，这就需要把资源上锁了。

如果只有线程1加锁，那是不是这个锁就没有意义了呢？

这个理解可以有

---