Update copyright headers
[qt:qt.git] / doc / src / porting / qt4-threads.qdoc
1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the documentation of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:FDL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Free Documentation License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Free
19 ** Documentation License version 1.3 as published by the Free Software
20 ** Foundation and appearing in the file included in the packaging of
21 ** this file.  Please review the following information to ensure
22 ** the GNU Free Documentation License version 1.3 requirements
23 ** will be met: http://www.gnu.org/copyleft/fdl.html.
24 ** $QT_END_LICENSE$
25 **
26 ****************************************************************************/
27
28 /*!
29     \page qt4-threads.html
30     \title Thread Support in Qt 4
31
32     \contentspage {What's New in Qt 4}{Home}
33     \previouspage The Qt 4 Style API
34
35     Qt 4 makes it easier than ever to write multithreaded
36     applications. More classes have been made usable from non-GUI
37     threads, and the signals and slots mechanism can now be used to
38     communicate between threads.
39
40     \section1 General Overview
41
42     QThread now inherits QObject. It emits signals to indicate that
43     the thread started or finished executing, and provides a few
44     slots as well.
45
46     Each thread can now have its own event loop. The initial thread
47     starts its event loops using QCoreApplication::exec(); other
48     threads can start an event loop using QThread::exec(). Like
49     QCoreApplication, QThread also provides an
50     \l{QThread::exit()}{exit(int)} function and a
51     \l{QThread::quit()}{quit()} slot.
52
53     An event loop in a thread makes it possible for the thread to use
54     certain non-GUI Qt classes that require the presence of an event
55     loop (such as QTimer, QTcpSocket, and QProcess). It also makes it
56     possible to connect signals from any threads to slots of a
57     specific thread. When a signal is emitted, the slot isn't called
58     immediately; instead, it is invoked when control returns to the
59     event loop of the thread to which the object belongs. The slot is
60     executed in the thread where the receiver object lives. See
61     \l{signals-and-slots-across-threads} and QObject::connect() for details.
62
63     Qt 4 also introduces a new synchronization class: QReadWriteLock.
64     It is similar to QMutex, except that it distinguishes between
65     "read" and "write" access to shared data and allows multiple
66     readers to access the data simultaneously. Using QReadWriteLock
67     instead of QMutex when it is possible can make multithreaded
68     programs more concurrent.
69
70     Since Qt 4, \l{implicitly shared} classes can safely be copied
71     across threads, like any other value classes. They are fully
72     reentrant. This is implemented using atomic reference counting
73     operations, which are implemented in assembly language for the
74     different platforms supported by Qt. Atomic reference counting is
75     very fast, much faster than using a mutex.
76
77     See \l{Thread Support in Qt} for more information.
78
79     \section1 Comparison with Qt 3
80
81     Earlier versions of Qt offered an option to build the library
82     without thread support. In Qt 4, threads are always enabled.
83
84     Qt 3 had a class called \c QDeepCopy that you could use to take a
85     deep copy of an implicitly shared object. In Qt 4, the atomic
86     reference counting makes this class superfluous.
87 */