Summary of QT multithreading programming (ii)--qmutex

The Qmutex class provides a sequential access between threads.

The purpose of Qmutex is to protect an object, data structure, or code snippet, so that only one thread can access it at the same time. (in Java terminology, it is similar to the Sync keyword "synchronized"). For example, here's a way to print two messages to the user:

[CPP]View PlainCopy

1. void SomeMethod ()
2. {
3. Qdebug ("Hello");
4. Qdebug ("World");
5. }

If this method is called in two threads at the same time, the order of the results will be:

  Hello  Hello  world    

If you are using a mutex:

[CPP]View PlainCopy

1. Qmutex Mutex;
3. void SomeMethod ()
4. {
5. Mutex.lock ();
6. Qdebug ("Hello");
7. Qdebug ("World");
8. Mutex.unlock ();
9. }

In Java terminology, this code should be:

[CPP]View PlainCopy

1. void SomeMethod ()
2. {
3. Synchronized {
4. Qdebug ("Hello");
5. Qdebug ("World");
6. }
7. }

Then only one thread at a time can run SomeMethod and the order of the messages is always correct. This is, of course, a very simple example, but it applies to anything that needs to happen at a specific frequency.

But you call lock () in one thread, and the other thread will attempt to call Lock () at the same location to block, knowing that the other thread will get the lock after the thread calls unlock (). A non-blocking selection of lock () is Trylock ().

Experimental section:

Scenario One:

[CPP]View PlainCopy

2. #include <QtCore/QCoreApplication>
4. #include <Qthread>
6. #include <QTextStream>
8. Class Mythreada: Public qthread {
10. Public
12. Virtual void run ();
14. };
16. Class mythreadb: Public qthread {
18. Public
20. Virtual void run ();
22. };
24. int number=6;
26. void Mythreada::run () {
28. Number *= 5;
30. Number/= 4;
32. }
34. void Mythreadb::run () {
36. Number *= 3;
38. Number/= 2;
40. }
42. int main (int argc, char *argv[])
44. {
46. Qcoreapplication app (argc, argv);
48. Mythreada A;
50. MYTHREADB b;
52. A.run ();
54. B.run ();
56. A.terminate ();
58. B.terminate ();
60. Qtextstream out (stdout);
62. out<<number;
64. return App.exec ();
66. }

The above code, very simple, wrote two threads, covering the Qthread pure virtual function run (), the two refactoring of the Run method is the global variable number operation,

The two methods are called sequentially in the main function, and after A.run () is executed, number is 7,b.run () after 10.

Scenario Two:

[CPP]View PlainCopy

2. #include <QtCore/QCoreApplication>
4. #include <Qthread>
6. #include <QTextStream>
8. Class Mythreada: Public qthread {
10. Public
12. Virtual void run ();
14. };
16. Class mythreadb: Public qthread {
18. Public
20. Virtual void run ();
22. };
24. int number=6;
26. void Mythreada::run () {
28. Number *= 5;
30. Sleep (1);
32. Number/= 4;
34. }
36. void Mythreadb::run () {
38. Number *= 3;
40. Sleep (1);
42. Number/= 2;
44. }
46. int main (int argc, char *argv[])
48. {
50. Qcoreapplication app (argc, argv);
52. Mythreada A;
54. MYTHREADB b;
56. A.start ();
58. B.start ();
60. A.wait ();
62. B.wait ();
64. Qtextstream out (stdout);
66. out<<number;
68. return App.exec ();
70. }

Operation Result:

number=11;

Using the Qthread method Start () is the same as opening two threads, it is worth noting that the wait () function, can not wait for itself, this is used to interact with multiple threads, so can not be used as sleep (). This function blocks the main thread when it is called in the main thread. If you want to let the child thread pause externally, the best way is to set a flag in the child thread, change the flag in the main thread, and judge in the run function of the child thread, by calling its protection function sleep () to achieve the purpose of the pause.

To view the source code, you have a clear concept:

[CPP]View PlainCopy

2. BOOL Qthread::wait (unsigned long time)
4. {
6. Q_d (Qthread);
8. Qmutexlocker Locker (&d->mutex);
10. if (D->id = = GetCurrentThreadID ()) {
12. Qwarning ("Qthread::wait:thread tried to wait on itself"); //When it is itself, return false directly
14. return false;
16. }
18. if (d->finished | |!d->running) //The thread associated with this thread object has ended execution (for example, returned from the Run function). Returns true if the thread ends.  Returns true if the thread has not started yet.
20. return true;
22. ++d->waiters;
24. Locker.mutex ()->unlock ();
30. BOOL ret = false;
32. switch (WaitForSingleObject (D->handle, Time)) { //Call Win's object handler function
34. Case WAIT_OBJECT_0: //Core object is activated, waiting for success
36. ret = true;
38. Break ;
40. Case wait_failed:
42. Qerrnowarning ("Qthread::wait:thread wait Failure");
44. Break ;
46. Case wait_abandoned:
48. Case Wait_timeout:
50. Default:
52. Break ;
54. }
56. Locker.mutex ()->lock ();
58. --d->waiters;
60. if (ret &&!d->finished) { //Although the response was successful, but the associated object did not end execution
62. //thread was terminated by someone else
64. d->terminated = true;
66. Qthreadprivate::finish (This, false);
68. }
70. if (d->finished &&!d->waiters) { //The associated object execution ends and the wait number is zero, the handle is closed.
72. CloseHandle (D->handle);
74. D->handle = 0;
76. }
78. return ret;
80. }

Scenario Three: (Mutex effect)

[CPP]View PlainCopy

2. #include <QtCore/QCoreApplication>
4. #include <Qthread>
6. #include <QTextStream>
8. #include <QMutex>
10. Class Mythreada: Public qthread {
12. Public
14. Virtual void run ();
16. };
18. Class mythreadb: Public qthread {
20. Public
22. Virtual void run ();
24. };
26. Qmutex Mutex;
28. int number=6;
30. void Mythreada::run () {
32. Mutex.lock ();
34. Number *= 5;
36. Sleep (1);
38. Number/= 4;
40. Mutex.unlock ();
42. }
44. void Mythreadb::run () {
46. Mutex.lock ();
48. Number *= 3;
50. Sleep (1);
52. Number/= 2;
54. Mutex.unlock ();
56. }
58. int main (int argc, char *argv[])
60. {
62. Qcoreapplication app (argc, argv);
64. Mythreada A;
66. MYTHREADB b;
68. A.start ();
70. B.start ();
72. A.wait ();
74. B.wait ();
76. Qtextstream out (stdout);
78. out<<number;
80. return App.exec ();
82. }

Operation Result:

number=10;

The experimental results show that QMUTEX protects the global variables, and only one thread can access it at the same time.

Only one mention is the use of Trylock (), if the above code is changed to Mutex.trylock (), then the execution result may be 11, because it is trying to lock the mutex. If the lock is obtained, the function returns True. If the mutex is already locked by another process, the function returns false instead of waiting until the lock is available.

and cannot add the sleep () function, otherwise prompt "A mutex must be unlocked in the same thread that locked it." Run error.

http://blog.csdn.net/mznewfacer/article/details/6966752

Summary of QT multithreading programming (ii)--qmutex