Lesson15-QT multithreading. Lesson15-QT multithreading 1, what is thread 1, thread process: a program is being executed, it is the smallest unit of the thread of resource allocation: The smallest unit of the process of program execution appears a lot of lesson15-QT multithreading
1. what is a thread?
1. thread
Process: A program being executed. it is the smallest unit of resource allocation.
Thread: minimum unit of program execution
Process has many drawbacks. first, because the process is the resource owner, there is a large space-time overhead for creation, revocation, and switching. Therefore, lightweight processes need to be introduced; second, due to the emergence of symmetric multi-processor (SMP), multiple operating units can be satisfied, while the parallel overhead of multiple processes is too large.
2. thread terminology
Concurrency means that at the same time, only one command can be executed, but multiple process commands are quickly rotated for execution, so that multiple processes can be executed simultaneously at a macro level.
It seems to happen at the same time
Parallelism refers to the simultaneous execution of multiple commands on multiple processors at the same time.
Real happening at the same time
Synchronization: calls with dependency between each other should not "occur at the same time", but synchronization is to prevent "happening at the same time ".
The concept of asynchronization is relative to synchronization. any two operations that are independent of each other are asynchronous, which indicates that things happen independently.
3. thread advantages
1) concurrency of developing programs in multi-processor
2) while waiting for slow IO operations, the program can execute other operations to improve concurrency
3) modular programming, which can clearly express the relationship between independent events in the program and clear the structure
4) a small amount of system resources are occupied.
Multi-thread does not have to be multi-processor
In GUI programs, multithreading is often used. one thread is used to respond to the interface, and other threads can process lengthy operations in the background.
Qt's object meta-system supports communication between objects in different threads using signals and slots.
II. QT multithreading
Multithreading in Qt is very simple. as long as the sub-class is QThread, there is a protected type run function in QThread. rewrite the run function to implement multithreading.
1. QT thread
Multithreading in Qt is very simple. as long as QThread is subclass and the run function is rewritten, multithreading can be implemented.
Class MyThread: public Thread
{
Public:
MyThread ();
Protected:
Void run ();
Private:
Volatile boolean stopped;
}
The run function is started by the thread's start method. The thread also has the isRunning method to determine whether the thread is running. The terminate method ends the thread.
2. semaphores for thread synchronization
Semaphores make the thread do not need to wait busy, is an extension of mutex. Using semaphores ensures that two key codes are not concurrent. When entering a piece of key code, the thread must obtain the Semaphore and release it when exiting. Semaphores can be accessed by multiple threads at the same time.
QSemaphore class of Qt semaphores:
Acquire () is used to obtain resources, and free () is used to release resources.
For producer and consumer examples, make sure that there is sufficient space during producer production and that there are resources in the space during consumer consumption.
QSemaphore freeByte (100) production has 100 space
QSemaphore useByte (0) the consumer has no resources
Producer
{
FreeByte. acquire ()
Byte = n
UseByte. release ()
}
Consumer
{
UseByte. acquire ()
Printf byte
FreeByte. release ()
}
3. conditional variables for thread synchronization
QWaitCondition allows the thread to wake up other threads under certain conditions. This can also be because the thread does not have to wait busy. the condition variable must be used together with the mutex.
QMutex mutex; QWaitCondition condition;
Condition. wait (& mutex)
Condition. wakeAll ()
The wait function unlocks the mutex and waits for it to return.
The wakeAll function will wake up all threads waiting for the mutex.
4. thread priority
The actual task may run a thread first, so the thread priority needs to be set.
The setPriority function can set the priority of a thread, or input the priority of a thread in the start function when the thread starts.
III. instances
1. multithreading
- #ifndef MYTHREAD_H
- #define MYTHREAD_H
- #include
- class MyThread : public QThread
- {
- Q_OBJECT
- public:
- MyThread();
- void stop();
- volatile bool stopped;
- protected:
- void run();
- };
- #endif
- #include "myThread.h"
- #include
- MyThread::MyThread()
- {
- stopped = false;
- }
- void MyThread::run()
- {
- int i=0;
- while(!stopped)
- {
- qDebug()<<"thread id:"
- i++;
- sleep(2);
- }
- stopped = false;
- }
- void MyThread::stop()
- {
- stopped = true;
- }
2. semaphores
- #ifndef PRODUCER_H
- #define PRODUCER_H
- #include
- class Producer : public QThread
- {
- Q_OBJECT
- public:
- Producer();
- protected:
- void run();
- };
- #endif
- #ifndef CONSUMER_H
- #define CONSUMER_H
- #include
- class Consumer : public QThread
- {
- Q_OBJECT
- public:
- Consumer();
- protected:
- void run();
- };
- #endif
- #include "producer.h"
- #include "consumer.h"
- #include
- #include
- #define SIZE 50
- QSemaphore freeByte(SIZE);
- QSemaphore useByte(0);
- Producer::Producer()
- {
- }
- void Producer::run()
- {
- for(int i=0; i
- {
- freeByte.acquire();
- qDebug()<<"produer:"<
- useByte.release();
- sleep(1);
- }
- }
- Consumer::Consumer()
- {
- }
- void Consumer::run()
- {
- for(int i=0; i
- {
- useByte.acquire();
- qDebug()<<"consumer:"<
- freeByte.release();
- sleep(2);
- }
- }
3. condition variables
- #ifndef THREAD_H
- #define THREAD_H
- #include
- class Producer : public QThread
- {
- Q_OBJECT
- public:
- Producer();
- protected:
- void run();
- };
- class Consumer : public QThread
- {
- Q_OBJECT
- public:
- Consumer();
- protected:
- void run();
- };
- #endif
- #include "thread.h"
- #include
- #include
- #include
- QMutex mutex;
- QWaitCondition empty, full;
- int num=0;
- int buffer[50];
- int useByte=0;
- Producer::Producer()
- {
- }
- void Producer::run()
- {
- for(int i=0; i<50; i++)
- {
- mutex.lock();
- if(useByte==50)
- empty.wait(&mutex);
- num++;
- buffer[i] = num;
- qDebug()<<"producer:"<
- useByte++;
- full.wakeAll();
- mutex.unlock();
- sleep(1);
- }
- }
- Consumer::Consumer()
- {
- }
- void Consumer::run()
- {
- for(int i=0; i<50; i++)
- {
- mutex.lock();
- if(useByte==0)
- full.wait(&mutex);
- qDebug()<<"consumer"<
- useByte--;
- empty.wakeAll();
- mutex.unlock();
- sleep(2);
- }
- }
Thread 1, what is thread 1, thread process: a program being executed, it is the smallest unit thread for resource allocation: The smallest unit process for program execution appears very...
