day06

回顾：
1 CREATE TABLE 表名 (列名 类型[约束],...,...);
2 DROP TABLE 表名;
3 INSERT INTO 表名 (列名,...) VALUES(数值,...);
4 DELETE FROM 表名 WHERE 条件;
5 UPDATE 表名 SET 列名=数值,... WHERE 条件;
6 SELECT 列名 FROM 表名  
    WHERE 条件  
        ORDER BY 列名  ASC/DESC;
=========
今天：
回顾：
pthread_create
pthread_join
pthread_detach
pthread_cancel
 
 
 
一 QT多线程
#include <QThread>
创建线程方法1：//不推荐
class Worker : public QObject
{
    Q_OBJECT
public slots:
    void doWork(const QString &parameter) {
        QString result;
        /* 耗时或可能阻塞操作 */
    }
};
 
class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller() {
        Worker *worker = new Worker;
        worker->moveToThread(&workerThread);
        //当发送operate信号时，Worker::doWork将被放到线程中执行
    connect(this, &Controller::operate,  
        worker, &Worker::doWork);
        workerThread.start();
    }
    ~Controller() {
        workerThread.quit();
        workerThread.wait();
    }
};
 
创建线程方法2:推荐使用该方法
--》继承QThread
--》重写run函数
class WorkerThread : public QThread
{
    Q_OBJECT
    void run(void){//线程入口函数
        /* 耗时或者可能阻塞代码 */
    }
};
void MyObject::startWorkInAThread()
{
    WorkerThread *workerThread  
    = new WorkerThread(this);
    //开启线程，WorkerThread::run将在独立线程中被执行
    workerThread->start();
}
 
相关的函数
1）线程阻塞
bool QThread::wait(unsigned long time = ULONG_MAX)
2）线程终止
void QThread::terminate()
3）开启线程
void start();
4）获取当前线程句柄（ID）
QThread::currentThreadId()
 
《案例》多线程打印消息
 
========================
二 QT线程同步
1 互斥量 QMutex
eg:
QMutex mutex;
int g_data = 0;
void ThreadA::run(){
    mutex.lock();
    g_data = g_data + 1;
    mutex.unlock();
}
void ThreadB::run(){   
    mutex.lock();
    g_data = g_data + 1;
    mutex.unlock();
}
 
2 读写锁 QReadWriteLock
eg:
int g_data = 0;
QReadWriteLock lock
void readerThread::run()
{  
   ..
   lock.lockForRead();
   accesc_data_without_modify(&g_data);
   lock.unlocked();
}
void WriterThread::run()
{  
   ..
   lock.lockForWrite();
   modify_data(&g_data);
   lock.unlocked();
}
 
3 信号量 QSemaphore
QSemaphore sema(1)  ==> QMutex mutex;
sema.acquire()      ==> mutex.lock();
sema.release()      ==> mutex.lock();
 
《生产者和消费者》
P操作：申请资源，将信号量S的值减1，S=S-1；
       如果S>=0,该线程继续执行；否则进入等待
 
V操作：释放资源，将信号量S的值加1，S=S+1；
       如果S<=0，说明有线程在等待，则唤醒等待的线程
问题：
1）生产者向仓库存数据，但是如果生产者速度太快，那么会把消费者还未读走的数据覆盖。
2）消费者从仓库取数据，但是如果消费者速度太快，那么将会越过生产者读到一些垃圾数据。
 
解决：使用两个信号
控制生产者信号量(freeSpace)，如果仓库满则阻塞；
控制消费者信号量(usedSpace),如果仓库为空则阻塞
 
 
生产者线程：
while(1){
   P(freeSpace)
   生产一个产品，存放到仓库
   V(usedSpac)
}
 
消费者线程：
while(1){
   P(usedSpace)
   从仓库取出一个数据消费
   V(freeSpace)
}
 
4 条件等待 QWaitCondition
 
练习1：使用QWaitCondition，重构生产者消费者案例
练习2：复习linux网络编程