本文简单介绍互斥锁的使用

互斥锁变量类型


pthread_mutex_t


1.互斥锁初始化

1.1 动态初始化  需要销毁


  int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);


 参数说明：

mutex：传入互斥锁的地址

attr：属性，一般传递NULL采用默认属性

1.2 静态初始化  不需要销毁


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


PTHREAD_MUTEX_INITIALIZER ：宏定义了一个结构体的值

2.加锁

1.1 阻塞的加锁接口


 int pthread_mutex_lock(pthread_mutex_t *mutex);


 mutex：传入互斥锁的地址

如果mutex中计数器值为1，则pthread_mutex_lock接口直接返回，表示加锁成功，同时mutex中的计数器的值会被置为0 

如果mutex中计数器值为0，则pthread_mutex_lock接口会阻塞在函数内部中，直到加锁成功

1.2 非阻塞加锁接口


 int pthread_mutex_trylock(pthread_mutex_t *mutex);


  mutex：传入互斥锁的地址

当mutex中的计数器值为1，则加锁成功直接返回 

当mutex中的计数器值为0，也会返回，但是这时候没有加锁成功，所以不能访问临界资源

 1.3 带有超时时间的加锁接口 


int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,

              const struct timespec *restrict abs_timeout); 


 mutex：传入互斥锁的地址，abs_timeout : 等待的时间

1.带有超时时间的加锁接口，当没有获取互斥锁时，会等待abs_timeout时间，在这段时间中加锁成功了，就直接返回，如果等待超时，就直接返回，但是表示加锁失败了，需要循环使用进行加锁

注意：非阻塞接口一般都是配合循环使用

3.解锁


int pthread_mutex_unlock(pthread_mutex_t *mutex);


 mutex：传入互斥锁的地址

1.不管是使用哪个接口进行加锁的互斥锁都可以通过这个接口进行解锁

2.解锁的时候，会将互斥锁中的计时器的值置为1，表示其它线程可以获取这个互斥锁

4.互斥锁的销毁


int pthread_mutex_destroy(pthread_mutex_t *mutex);


 mutex：传入互斥锁的地址

针对动态初始化的互斥锁进行销毁

5.互斥锁的应用

这是一个黄牛抢票程序，4个工作线程代表4个黄牛，临界资源代表票，规则为：一张票只能被一个黄牛拿到。

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

#define THREADCOUNT 4
// 票
int g_titcks = 100;
//定义一个互斥锁‘
pthread_mutex_t g_lock; 

void* func(void* arg)
{
  (void* ) arg;
  while(1)
  {
    //加锁
    pthread_mutex_lock(&g_lock);
    if( g_titcks > 0)
    {
      printf("i am work thread %p , i have titck %d\n",pthread_self(), g_titcks);
      g_titcks--;
    }
    else 
    {
      //解锁
      pthread_mutex_unlock(&g_lock);
      break;
    }
      //解锁
       pthread_mutex_unlock(&g_lock);
  }
  return NULL;
}
int main()
{

  pthread_t tid[THREADCOUNT];
  //互斥锁初始化
  pthread_mutex_init(&g_lock,NULL);
  for(int i = 0; i < THREADCOUNT; i++)
  {
    int ret = pthread_create(&tid[i], NULL, func, NULL);
    if(ret < 0 )
    {
      perror("pthread_ create \n");
      return -1;
    }
  }
  for(int i = 0; i < THREADCOUNT; i++)
  {
    pthread_join(tid[i],NULL);
  }
  //互斥锁销毁
  pthread_mutex_destroy(&g_lock);
  return 0;
}



 

qt互斥锁的使用

 

class CallbackStorage
{
public:
    int insertCallback(const QJSValue &callback)
    {
        QMutexLocker locker(&m_mtx);
        const int nextId = qMax(++m_counter, 0);
        if (nextId == 0)
          m_counter = 1;

        m_callbacks.insert(nextId, callback);
        return nextId;
    }

    QJSValue takeCallback(int callbackId)
    {
        QMutexLocker lock(&m_mtx);
        return m_callbacks.take(callbackId);
    }

private:
    QMutex m_mtx;
    int m_counter;
    QHash<int, QJSValue> m_callbacks;
};

} // namespace

 

MFC多线程互斥锁的使用
本例演示在MFC中使用多线程。第一部分实现多线程的开启、暂停、继续、注销（见上一篇文章MFC多线程的开启、暂停、继续和注销）。第二部分实现两个线程互斥锁的使用。

演示系统为Win10，平台为VS2017（MFC），主要使用类为CWinThread。
第二部分：
1.在原有基础上（见上一篇文章MFC多线程的开启、暂停、继续和注销）添加一个EDIT控件和一个线程MyThread2。



2.在ThreadTestDlg.h头文件中添加函数及变量声明：
static UINT MyThread2(LPVOID* pParam);//线程函数
CWinThread *Thread2;//线程2

3.在ThreadTestDlg.cpp实现文件上部中添加变量：
CMutex Mutex;//用于互斥锁

修改文件末尾线程1函数定义：
//线程1函数
UINT CThreadTestDlg::MyThread1(LPVOID* pParam)
{
	CThreadTestDlg *ap1 = (CThreadTestDlg *)pParam;//获取主类指针，在多线程类中使用主类变量需要使用指针ap1->
	CSingleLock singleLock(&Mutex);
	while(1)
	{
		if (ThreadKill)
		{
			DWORD dwExitCode;//指定线程的退出代码
			GetExitCodeThread(ap1->Thread1, &dwExitCode);//获取线程1的退出代码
			AfxEndThread(dwExitCode, TRUE);//退出线程
		}
		else
		{
			//singleLock.Lock();//没被调用就上锁自己用，已被调用就等着
			//if (singleLock.IsLocked()) 
			{
				n=1;
				strn.Format(_T("%d"), n);
				ap1->SetDlgItemText(IDC_EDIT1, strn);
				Sleep(30);
			}
			//singleLock.Unlock();//解锁
		}
	}
	return 0;
}

4.添加线程2函数定义：
UINT CThreadTestDlg::MyThread2(LPVOID* pParam)
{
	CThreadTestDlg *ap2 = (CThreadTestDlg *)pParam;//获取主类指针，在多线程类中使用主类变量需要使用指针ap1->
	CSingleLock singleLock(&Mutex);
	while (1)
	{
		if (ThreadKill)
		{
			DWORD dwExitCode;//指定线程的退出代码
			GetExitCodeThread(ap2->Thread2, &dwExitCode);//获取线程2的退出代码
			AfxEndThread(dwExitCode, TRUE);//退出线程
		}
		else
		{
			//singleLock.Lock();//没被调用就上锁自己用，已被调用就等着
			//if (singleLock.IsLocked())
			{
				n=-1;
				strn.Format(_T("%d"), n);
				ap2->SetDlgItemText(IDC_EDIT2, strn);
				Sleep(30);
			}
			//singleLock.Unlock();//解锁
		}
	}
	return 0;
}

5.修改按钮响应函数：
void CThreadTestDlg::OnBnClickedButton1()
{
	n = 0;
	ThreadKill = FALSE;
	Thread1 = AfxBeginThread((AFX_THREADPROC)MyThread1, this);//启动线程
	Thread2 = AfxBeginThread((AFX_THREADPROC)MyThread2, this);//启动线程
}

void CThreadTestDlg::OnBnClickedButton2()
{
	Thread1->SuspendThread(); //暂停线程
	Thread2->SuspendThread(); //暂停线程
}

void CThreadTestDlg::OnBnClickedButton3()
{
	Thread1->ResumeThread(); //继续线程 
	Thread2->ResumeThread(); //继续线程 
}

void CThreadTestDlg::OnBnClickedButton4()
{
	ThreadKill = TRUE;//
	Thread1->ResumeThread(); //调用继续线程,排除线程处于暂停模式无法注销的情况。若线程处于工作状态，调用此函数无作用。
	Thread2->ResumeThread(); //调用继续线程,排除线程处于暂停模式无法注销的情况。若线程处于工作状态，调用此函数无作用。
}

6.编译运行。这是未加互斥锁的情况下，程序中，我们在线程1将n赋值为1并在EDIT1显示；在线程2中将同一个变量n赋值为-1并在EDIT2显示。理论上控件上应分别显示1和-1，但实际上，会出现同时显示1，或同时显示-1或显示-1和1的情况。这是由于线程间同时调用同一变量造成的（严格来讲并不是同时，而是比如线程1赋值为1后还没打印出来就被线程2赋值为-1了，所以造成最后打印出来都是-1，其他情况同理）。





7.互斥锁使用。上面修改中其实已经加入了互斥锁的必要说明，只需要把注销掉的代码复原即可实现。实际操作步骤如下：

①添加类变量声明
 CMutex Mutex;//用于互斥锁

②在线程中定义互斥锁类变量
CSingleLock singleLock(&Mutex);

③在线程中添加处理代码
singleLock.Lock();//没被调用就上锁自己用，已被调用就等着
			if (singleLock.IsLocked()) 
			{
				//在此添加处理代码
			}
			singleLock.Unlock();//解锁

8.修改后编译运行，可以看到使用互斥锁后，程序按预想的形式运行，EDIT1稳定的显示1，EDIT2稳定的显示-1。



9.使用互斥锁后，当进入线程1时会先检查变量是否被调用，没有的话就上锁给自己用，待自己用完再解锁，如果变量已经被调用上锁了，那么久等待变量释放。这样在一个线程的运行周期内，其他线程就无法更改变量。

目录

1. 互斥锁原理

2. 互斥锁相关函数

3. 互斥锁使用过程

4. 互斥锁使用示例

5. 死锁

1. 互斥锁原理



如上图所示：如果多个线程要访问一段共享资源的内存区域时，其中一个线程（如图中线程1）首先读取共享区域时，会在共享区域外设置一把互斥锁，其它线程阻塞在互斥锁处，线程1结束共享资源的访问后，会解锁该内存区域，此时其它的线程才可以继续访问共享资源的内存区域。本来多线程访问数据时是并行访问内存区域的，加上互斥锁后变为串行处理。

多线程编程是建议使用互斥锁，这样可以对公共区域的数据进行保护。互斥锁的缺点就是串行，数据访问的效率会有一定的降低。

2. 互斥锁相关函数

1.创建互斥锁函数
pthread_mutex_t mutex;

2.初始化互斥锁函数：
int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
                       const pthread_mutexattr_t *restrict attr
                        ); 
    参数1：传出参数，调用是创建的互斥锁变量。
    参数2：传入参数，互斥锁属性，一般为NULL表示为默认属性
    这里的restrict关键字，表示指针指向的内容只能通过这个指针进行修改
    restrict关键字作用可以理解为：
	    用来限定指针变量。被该关键字限定的指针变量所指向的内存操作，必须由本指针完成。
    
    初始化可以使用静态初始化和动态初始化，示例：
    pthread_mutex_t mutex;
		1. pthread_mutex_init(&mutex, NULL);   			动态初始化。
		2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;	静态初始化。

3.加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
     参数：mutex
     没有上锁，当前线程会将这把锁上锁
     已经上锁，当前线程会阻塞在此
              锁被打开之后，线程会解除阻塞

4.尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
      参数：mutex
      没有上锁：同上
      已经上锁，不阻塞返回

5.解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

6.销毁一个互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);


3. 互斥锁使用过程


（1）创建互斥锁：pthread_mutex_t mutex;

（2）初始化互斥锁： pthread_mutex_init(&mutex, NULL);

（3）找到线程共同操作的共享资源

           加锁：prhread_mutex_lock(&mutex);     //如果共享区域已经上锁，会阻塞线程

                      pthread_mutex_trylock(&mutex);   //如果共享区域已经上锁，直接返回，不会阻塞。

（4）访问内存区域

（5）解锁：pthread_mutex_unlock(&mutex);

（6）销毁：pthread_mutex_destory(&mutex);


 使用注意：

尽量保证锁的粒度，越小越好，一般访问共享数据前加锁，访问结束立即解锁。

        互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

        加锁： --操作， 阻塞线程。

        解锁： ++操作， 唤醒阻塞在锁上的线程。

        try锁：尝试加锁，成功--。失败，返回。同时设置错误号 EBUSY

4. 互斥锁使用示例

pthread_mutex.c：主线程建立两个子线程对全局变量进行++操作。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>


#define MAX 10000
// 全局变量
int number;
//创建一把互斥锁
pthread_mutex_t mutex;


// 线程A处理函数
void* funcA_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        //访问全局变量之前加锁
        //如果mutex被锁上了，代码阻塞在当前位置
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread A, id = %lu, number = %d\n", pthread_self(), number);
        //解锁
        pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}
// 线程B处理函数 
void* funcB_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread B, id = %lu, number = %d\n", pthread_self(), number);
                pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}

/*主函数创建两个线程，分别操作共享区域内存：全局变量number*/
int main(int argc, const char* argv[])
{
    pthread_t p1, p2;
        //初始化互斥锁
    pthread_mutex_init(&mutex,NULL);
 
    // 创建两个子线程
    pthread_create(&p1, NULL, funcA_num, NULL);
    pthread_create(&p2, NULL, funcB_num, NULL);
 
    // 阻塞，资源回收
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
 
        //释放互斥锁资源
    pthread_mutex_destroy(&mutex);
 
    return 0;
}

运行结果：AB两个线程逐个访问共享内存区域。


5. 死锁

程序运行是要避免死锁的情况。通常出现死锁的情况有两种：

       1.  对一个锁反复lock：对一个地方使用了两次锁，没有及时解锁

2. 两个线程，各自持有一把锁，请求另一把锁，如下图所示:A，B两个线程访问AB两个共享数据区域时。



解决方法：

        1. 让线程按照一定的顺序去访问共享资源

        2. 在访问的其他锁的时候，需要先将字节的锁解开

        3.trylock方式定义锁