• Qt学习笔记 线程(一)


    Qt中的线程是与平台无关的

    QThread 提供了创建一个新线程的方法

    新建一个线程,继承QThread并重写它的run()当调用 start()函数时会调用重载的run()函数

    例:

    #ifndef MYTHREAD_H
    #define MYTHREAD_H
    #include <QThread>
    
    class MyThread : public QThread
    {
        Q_OBJECT
    public:
        bool stop ;
        explicit MyThread(QObject *parent = 0);
        void run();
    signals:
    
    public slots:
    
    };
    #endif // MYTHREAD_H
    #include "mythread.h"
    #include<QDebug>
    MyThread::MyThread(QObject *parent) :
        QThread(parent)
    {
        stop = false;
    }
    void MyThread::run()
    {
        for(int i=0;i<1000;i++)
        {
            if(stop)break;
            qDebug()<<i;
            QThread::sleep(1);
        }
    }
    #include <QCoreApplication>
    #include "myobject.h"
    #include <QThread>
    #include<QDebug>
    #include "mythread.h"
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        MyThread myThread;
        myThread.start();
        QThread::sleep(10);
        myThread.stop=true;
        return a.exec();
    }

    看一下Qt中包含的线程类:

    QThread 所有线程的基类,提供了创建一个线程的方法

    QThreadStorge 提供一逐线程数据存储

    QMutex 提供相互排斥的锁,或互斥量

    QMutexLocker 可以自动对QMutex加锁与解锁

    QReadWirterLock 提供了一个可以同时读操作的锁

    QreadLocker与QwriteLocker可以自动对QReadWriteLock加锁与解锁 

    QSempHore提供了一个整形信号量,是互斥的泛化

    QWaitCondition提供了一种方法,使线程可以在被另外线程唤醒之前一直休眠

    线程的同步

    QMutex 提供相互排斥的锁,或互斥量

    QMetex提供了lock和Unlock函数,如果 一个已经锁定 这个互斥量,只有这个线程unlock后其它线程才可以

    访问

    把上边的例子做一下修改,只是为了方便大家理解,这个例子没什么作用

    #ifndef MYTHREAD_H
    #define MYTHREAD_H
    #include <QThread>
    
    class QMutex;
    class MyThread : public QThread
    {
        Q_OBJECT
    private:
        QMutex qm;
        bool stop;
    public:
        explicit MyThread(QObject *parent = 0);
        void run();
        void SetFlg(bool flg);
    signals:
    public slots:
    
    };
    #endif // MYTHREAD_H
    #include "mythread.h"
    #include<QDebug>
    #include<QMutex>
    MyThread::MyThread(QObject *parent) :
        QThread(parent)
    {
        stop = false;
    }
    void MyThread::SetFlg(bool flg)
    {
        qm.lock();
        stop=flg;
        qm.unlock();
    }
    
    void MyThread::run()
    {
        for(int i=0;i<1000;i++)
        {
            qm.lock();
            if(stop)
            {
                qm.unlock();
                break;
            }
            qDebug()<<i;
            QThread::sleep(1);
            qm.unlock();
        }
    }
    #include <QCoreApplication>
    #include "myobject.h"
    #include <QThread>
    #include<QDebug>
    #include "mythread.h"
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        MyThread myThread;
        myThread.start();
        QThread::sleep(10);
        myThread.SetFlg(true);
        return a.exec();
    }

    使用QMutex时要小心因为如果 lock()后没有unlock()会导致死锁别的线程就

    永远也不能访问资源了

    Qt提供了QMutexLocker来解决这个问题

    修改我们的app文件

    #include "mythread.h"
    #include<QDebug>
    #include<QMutex>
    #include<QMutexLocker>
    MyThread::MyThread(QObject *parent) :
        QThread(parent)
    {
        stop = false;
    }
    void MyThread::SetFlg(bool flg)
    {
        QMutexLocker locker(&qm);
        stop=flg;
    }
    
    void MyThread::run()
    {
        QMutexLocker locker(&qm);
        for(int i=0;i<1000;i++)
        {
            if(stop)
            {
                break;
            }
            qDebug()<<i;
            QThread::sleep(1);
    
        }
    }

    QMutexLocker会自己unluck

    QMutexLocker也提供了一个mutex()成员函数返回QMutexLocker操作的互斥量。对于需要访问互斥量是十分有用的,比如QWaitCondition::wait()。

    QReadWirterLock 

    用mutext进行线程同步有一个问题某个时刻只许一个线程访问资源如果同时有多个线程对共享资源进行访问,

    同时有写操作线程那么这种情况下采用mutex就会成为程序的瓶颈。使用QReadWriteLock来实现多线程

    读操作,一个线程写操作,写线程执行时会阻塞所有的读线程,而读线程运行不需要进行同步

    QReadWriteLock lock;
    
    void ReaderThread::run()
    {
        ...
        lock.lockForRead();
        read_file();
        lock.unlock();
        ...
    }
    
    void WriterThread::run()
    {
        ...
        lock.lockForWrite();
        write_file();
        lock.unlock();
        ...
    }

    QreadLocker和QWriteLocker类是对QReadWirterLock 的简化

    它们会自动unluck();

    QReadWriteLock lock;
    
    QByteArray readData()
    {
        QReadLocker locker(&lock);
        ...
        return data;
    }

    相当于QReadWirterLock 的写法如下

    QReadWriteLock lock;
    
    QByteArray readData()
    {
        lock.lockForRead();
        ...
        lock.unlock();
        return data;
    }
  • 相关阅读:
    Nginx之——日志按日期分割的实现(基于CentOS操作系统)
    git忽略已加入到版本库的文件
    Linux系统下查看已经登录用户并踢出的方法
    nginx代理后,获取request的ip
    Spring Aop 修改目标方法参数和返回值
    nginx防止DDOS攻击配置
    SQL Server 合并复制遇到identity range check报错的解决
    SQL Saturday 北京将于7月25日举办线下活动,欢迎参加
    T-SQL检查停止的复制作业代理,并启动
    揭开SQL注入的神秘面纱PPT分享
  • 原文地址:https://www.cnblogs.com/li-peng/p/3653781.html
Copyright © 2020-2023  润新知