1、多线程间的互斥

临界资源–每次只允许一个线程进行访问的资源

线程间的互斥–多个线程在同一个时刻需要访问临界资源

QMute类是一把线程锁，保证线程间的互斥–利用线程锁能够保证临界资源的安全性

QMutex中的关键成员函数

void lock()–当锁空闲时，获取锁并继续执行；当锁被获取时，阻塞并等待释放

void unlock()–释放锁(同一把锁的获取和释放必须在同一线程中成对出现 )

1.1、生产消费者问题

1.有n个生成者同时制造产品，并把产品放入仓库中

2.有m个消费者同时需要从仓库中取出产品

所定的规则是–当仓库未满，任意生产者可以存入产品，当仓库未空，任意消费者可以取出产品

代码示例

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QDebug>

static QMutex g_mutex;//线程锁
static QString g_store;

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            g_mutex.lock();

            g_store.append(QString::number((count++) % 10));

            qDebug() << objectName() << " : " + g_store;

            g_mutex.unlock();

            msleep(1);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            g_mutex.lock();

            if( g_store != "" )
            {
                g_store.remove(0, 1);

                qDebug() << objectName() << " : " + g_store;
            }

            g_mutex.unlock();

            msleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p;
    Customer c;

    p.setObjectName("Producer");
    c.setObjectName("Customer");

    p.start();
    c.start();

    return a.exec();
}

运行的结果

【领QT开发教程学习资料，点击→「链接」←莬费领取，先码住不迷路~】

1.2、线程的死锁概念

线程间相互等待临界资源而造成彼此无法继续执行

发生死锁的条件

1.系统中存在多个临界资源且临界资源不可抢占

2.线程需要多个临界资源才能继续执行

死锁的避免

1.对所有的临界资源都分配一个唯一的序号

2.对应的线程锁也分配同样的序号

3.系统中的每个线程按照严格递增的次序请求资源

信号量的概念

1.信号量是特殊的线程锁

2.信号量允许N个线程同时访问临界资源

3.Qt支持信号量

#include <QtCore/QCoreApplication>
#include <QThread>
#include <QSemaphore>
#include <Qdebug>

const int SIZE = 5;
unsigned char g_buff[SIZE] = {0};
QSemaphore g_sem_free(SIZE);
QSemaphore g_sem_used(0);

class Producer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            int value = qrand() % 256;

            g_sem_free.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( !g_buff[i] )
                {
                    g_buff[i] = value;

                    qDebug() << objectName() << " generate: {" << i << ", " << value << "}";

                    break;
                }
            }

            g_sem_used.release();

            sleep(2);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            g_sem_used.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( g_buff[i] )
                {
                    int value = g_buff[i];

                    g_buff[i] = 0;

                    qDebug() << objectName() << " consume: {" << i << ", " << value << "}";

                    break;
                }
            }

            g_sem_free.release();

            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1;
    Producer p2;
    Producer p3;

    p1.setObjectName("p1");
    p2.setObjectName("p2");
    p3.setObjectName("p3");

    Customer c1;
    Customer c2;

    c1.setObjectName("c1");
    c2.setObjectName("c2");

    p1.start();
    p2.start();
    p3.start();

    c1.start();
    c2.start();
    
    return a.exec();
}

运行结果图

2、信号与槽的连接方式

深入信号与槽的连接方式

bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)信号与槽的连接方式决定槽函数调用时候的相关行为

需要注意的是–每一个线程都有自己的事件队列，线程通过事件队列接收信号，信号在事件循环中被处理

1.Qt::DirectConnection–立即调用–直接在发送信号的线程中调用槽函数，等价于槽函数的实时调用

2.Qt::QueuedConnection–异步调用–信号发送至目标线程的事件队列，由目标线程处理；当前线程继续向下执行

3.Qt::BlockingQueuedConnection–同步调用–信号发送至目标线程的事件队列，由目标线程处理；当前线程等待槽函数返回，之后继续向下执行

4.Qt::AutoConnection–默认连接

AutoConnection是connect函数第五个参数的默认值，也是工程最常用的连接方式

5.Qt::UniqueConnection–单一连接–功能与AutoConnection相同，自动确定连接类型，同一个信号与同一个槽函数只有一个连接