专栏导读

[4 数据库操作](#4 数据库操作)

[4.1 连接数据库](#4.1 连接数据库)

[4.2 执行 SQL 查询和更新：](#4.2 执行 SQL 查询和更新：)

[4.3 使用模型和视图显示数据](#4.3 使用模型和视图显示数据)

[5 多线程编程](#5 多线程编程)

[5.1 多线程编程的概念和优势](#5.1 多线程编程的概念和优势)

[5.2 在 PyQt 中使用多线程](#5.2 在 PyQt 中使用多线程)

[5.3 处理多线程间的同步和通信问题](#5.3 处理多线程间的同步和通信问题)

[5.3.1 信号槽机制](#5.3.1 信号槽机制)

[5.3.2 线程安全的数据访问](#5.3.2 线程安全的数据访问)

[QMutex 和 QMutexLocker](#QMutex 和 QMutexLocker)

专栏导读

专栏订阅地址： https://blog.csdn.net/qq_35831906/category_12375510.html

4 数据库操作

PyQt6中的数据库操作主要涉及到Qt的SQL模块，该模块提供了用于连接和管理数据库的功能。下面是一个关于PyQt6数据库操作的概述：

数据库连接： 使用QSqlDatabase类建立与数据库的连接。可以连接到各种数据库引擎，例如SQLite、MySQL、PostgreSQL等。连接需要指定数据库类型、主机、用户名、密码等信息。

数据库查询： 使用QSqlQuery类执行SQL查询语句，例如SELECT、INSERT、UPDATE等。查询结果可以通过迭代获取。

模型-视图架构： PyQt6提供了QSqlTableModel和QSqlQueryModel等模型类，用于将数据库数据与Qt的视图类（如QTableView）连接起来。这使得在表格视图中展示和编辑数据库中的数据变得更加容易。

事务管理： 可以使用QSqlDatabase.transaction()和QSqlDatabase.commit()来进行数据库事务的管理，确保数据的一致性和完整性。

数据绑定： 使用bindValue()方法可以将变量绑定到SQL查询，这有助于防止SQL注入攻击。

错误处理： 数据库操作可能会出现错误，通过检查QSqlQuery的lastError()可以获取详细的错误信息。

4.1 连接数据库

使用 Qt 的 QSqlDatabase 类可以连接到数据库。以下是一个简单的示例：

python 复制代码

from PyQt6.QtSql import QSqlDatabase

db = QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("my_database.db")
if db.open():
    print("Connected to database")
else:
    print("Failed to connect")

4.2 执行 SQL 查询和更新：

你可以使用 QSqlQuery 类来执行 SQL 查询和更新操作。以下是一个示例：

python 复制代码

from PyQt6.QtSql import QSqlQuery

query = QSqlQuery()
query.exec("SELECT * FROM employees")
while query.next():
    name = query.value("name")
    print("Employee name:", name)

4.3 使用模型和视图显示数据

Qt 提供了模型-视图架构来显示数据库中的数据。例如，可以使用 QSqlTableModel 来在 QTableView 中显示数据。以下是一个示例：

python 复制代码

import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QTableView, QVBoxLayout, QWidget, QPushButton, QLineEdit, QDockWidget
from PyQt6.QtSql import QSqlDatabase, QSqlTableModel, QSqlQuery
from PyQt6.QtCore import Qt

class AddDataDialog(QWidget):
    def __init__(self, model):
        super().__init__()
        self.model = model

        layout = QVBoxLayout()
        self.setLayout(layout)

        # 添加姓名输入框
        self.name_input = QLineEdit(self)
        layout.addWidget(self.name_input)

        # 添加职位输入框
        self.position_input = QLineEdit(self)
        layout.addWidget(self.position_input)

        # 添加 "Add Data" 按钮，并连接到添加数据函数
        add_button = QPushButton("Add Data", self)
        add_button.clicked.connect(self.add_data)
        layout.addWidget(add_button)

    def add_data(self):
        # 获取姓名和职位输入框的内容
        name = self.name_input.text()
        position = self.position_input.text()

        # 准备插入数据的SQL查询
        query = QSqlQuery()
        query.prepare("INSERT INTO employees (name, position) VALUES (?, ?)")
        query.bindValue(0, name)
        query.bindValue(1, position)
        if query.exec():
            print("Data added successfully")
            self.model.select()  # 刷新表格数据
        else:
            print("Error adding data:", query.lastError().text())

def create_database_connection():
    # 创建数据库连接
    db = QSqlDatabase.addDatabase("QSQLITE")
    db.setDatabaseName("employees.db")

    if not db.open():
        print("Error: Could not open database.")
        return None

    return db

def create_table(db):
    # 创建表格的SQL查询
    query = QSqlQuery()
    query.exec("CREATE TABLE IF NOT EXISTS employees (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, position TEXT)")

def setup_model(db):
    # 设置数据库表格模型
    model = QSqlTableModel()
    model.setTable("employees")
    model.setEditStrategy(QSqlTableModel.EditStrategy.OnManualSubmit)  # 手动提交更改
    model.select()

    return model

if __name__ == "__main__":
    app = QApplication(sys.argv)

    db = create_database_connection()
    if not db:
        sys.exit(1)

    create_table(db)
    model = setup_model(db)

    view = QTableView()
    view.setModel(model)

    add_data_dialog = AddDataDialog(model)

    window = QMainWindow()
    window.setWindowTitle("Database Table Example")
    window.setCentralWidget(view)
    window.setGeometry(100, 100, 800, 600)

    add_data_button = QPushButton("Add Data", window)
    add_data_button.clicked.connect(add_data_dialog.show)

    # 创建 DockWidget 并添加到主窗口的右侧停靠区
    dock_widget = QDockWidget("Add Data", window)
    dock_widget.setWidget(add_data_dialog)
    window.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock_widget)

    window.show()

    sys.exit(app.exec())

5 多线程编程

5.1 多线程编程的概念和优势

PyQt6中的多线程编程允许你在应用程序中同时执行多个任务，以提高性能、响应速度和资源利用率。在使用多线程时，你需要注意线程之间的同步和通信，以避免数据竞争和其他并发问题。以下是PyQt6多线程编程的概述：

线程类（QThread）： QThread 是 PyQt6 提供的线程基类，用于创建和管理线程。你可以继承 QThread 并实现 run() 方法来定义线程的执行逻辑。

线程安全性： 在多线程环境中，多个线程可能同时访问和修改共享资源。确保对共享资源的访问是线程安全的是很重要的，可以使用互斥锁（QMutex）来控制对共享资源的访问。

信号和槽机制： 在多线程中，通常不能直接在非主线程中更新用户界面。可以使用信号和槽机制，通过在主线程中处理信号来更新界面，从而避免线程间的界面更新问题。

多线程的应用场景： 多线程在以下情况下特别有用：

执行耗时操作，如文件读写、网络请求等，以避免主线程阻塞。

实现实时数据刷新，如传感器数据、图表数据等。

并发处理多个任务，提高程序的整体性能。

线程同步和通信： 多线程编程需要考虑线程之间的同步和通信。合适的同步机制（如互斥锁、信号量、条件变量等）和通信机制（如队列、信号槽等）可以确保线程间的正确协作。

避免死锁和线程饥饿： 死锁和线程饥饿是多线程编程中常见的问题。确保正确地设计和组织线程同步和通信，以避免出现这些问题。

总之，多线程编程可以显著提高应用程序的性能和响应能力，但也需要仔细考虑线程安全性和正确的同步机制。PyQt6提供了一些类和工具来帮助你实现多线程应用程序，但需要小心处理潜在的并发问题。

5.2 在 PyQt 中使用多线程

在 PyQt 中，你可以使用 QThread 类来创建和管理线程。以下是一个示例，演示如何在一个线程中执行一个耗时的任务：

python 复制代码

from PyQt6.QtCore import QThread, pyqtSignal

class WorkerThread(QThread):
    result_ready = pyqtSignal(str)

    def run(self):
        # 执行耗时任务
        result = "Task result"
        self.result_ready.emit(result)

thread = WorkerThread()
thread.result_ready.connect(lambda result: print("Result:", result))
thread.start()

5.3 处理多线程间的同步和通信问题

在多线程编程中，处理线程间的同步和通信问题是至关重要的，以确保数据的一致性和应用程序的稳定性。PyQt 提供了一些机制来帮助解决这些问题，其中最重要的是信号槽机制和线程安全的数据访问。

5.3.1 信号槽机制

信号槽机制是 PyQt 中用于线程间通信的重要工具。它允许一个对象（信号的发出者）发出信号，而另一个对象（槽函数的接收者）将信号连接到槽函数，从而在信号触发时执行相应的操作。这在多线程环境下特别有用，因为它避免了直接的线程间共享数据。

以下是一个简单的示例，演示如何在多线程中使用信号槽机制：

python 复制代码

import sys
from PyQt6.QtCore import QThread, pyqtSignal
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton

class WorkerThread(QThread):
    result_ready = pyqtSignal(str)

    def run(self):
        result = "Task result"
        self.result_ready.emit(result)

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Thread Communication Example")
        self.setGeometry(100, 100, 400, 300)

        self.button = QPushButton("Start Task", self)
        self.button.setGeometry(150, 150, 100, 30)
        self.button.clicked.connect(self.start_thread)

    def start_thread(self):
        self.thread = WorkerThread()
        self.thread.result_ready.connect(self.handle_result)
        self.thread.start()

    def handle_result(self, result):
        print("Result:", result)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MyWindow()
    window.show()
    sys.exit(app.exec())

5.3.2 线程安全的数据访问

当多个线程同时访问共享数据时，很容易出现竞争条件和数据不一致的问题。为了避免这些问题，你需要使用互斥锁（mutex）来保护共享数据的访问。PyQt 中的 QMutex 和 QMutexLocker 可以帮助你实现线程安全的数据访问。

以下是一个简单的示例，演示如何在多线程中安全地访问共享数据：

python 复制代码

import sys
from PyQt6.QtCore import QThread, QMutex, QMutexLocker

class SharedData:
    def __init__(self):
        self.mutex = QMutex()  # 用于保护共享数据的互斥锁
        self.data = 0

    def increment(self):
        locker = QMutexLocker(self.mutex)  # 加锁
        self.data += 1

class WorkerThread(QThread):
    def __init__(self, shared_data):
        super().__init__()
        self.shared_data = shared_data

    def run(self):
        for _ in range(10):
            self.shared_data.increment()

if __name__ == "__main__":
    shared_data = SharedData()  # 创建共享数据对象
    threads = [WorkerThread(shared_data) for _ in range(4)]  # 创建多个工作线程

    for thread in threads:
        thread.start()  # 启动工作线程

    for thread in threads:
        thread.wait()  # 等待所有工作线程完成

    print("Shared data:", shared_data.data)  # 打印最终共享数据的值

输出：

在这个示例中，每个工作线程在循环中执行10次的增量操作，使用互斥锁确保在任何时候只有一个线程可以访问和修改SharedData对象的data属性。这样可以避免数据竞争和不一致的情况。

注意，这个示例使用了Python中的多线程和互斥锁，与Qt中的线程和互斥锁略有不同。确保你的环境中同时存在Qt库和Python的线程支持（例如PyQt6.QtCore和threading库），以便代码可以正确运行。

5.4 避免死锁和线程饥饿

避免死锁和线程饥饿是多线程编程中的关键问题。死锁指的是多个线程彼此等待对方释放锁，导致程序无法继续执行。线程饥饿是指某个线程长时间无法获得所需的资源或锁，导致其他线程占用资源，使得该线程无法继续执行。以下是在PyQt6中避免死锁和线程饥饿的详解和示例：

避免死锁：

有序获取锁： 当多个线程需要获取多个锁时，确保它们按照相同的顺序获取锁，这可以减少死锁的风险。

超时机制： 在获取锁时使用超时机制，如果无法在一定时间内获取锁，就放弃并释放已有的锁。

避免线程饥饿：

公平性： 使用公平的锁和资源分配策略，确保所有线程都有平等的机会获得资源，避免某个线程长时间无法获得所需资源。

优先级： 在某些情况下，可以通过为线程设置不同的优先级，确保高优先级线程不会长时间无法获得资源。

以下是一个简单的示例，展示如何在PyQt6中使用QMutex来避免死锁和线程饥饿：

python 复制代码

import sys
from PyQt6.QtCore import QThread, QMutex, QMutexLocker

# 共享资源类，用于展示互斥锁的使用来避免死锁和线程饥饿
class SharedResource:
    def __init__(self):
        self.mutex1 = QMutex()  # 第一个互斥锁
        self.mutex2 = QMutex()  # 第二个互斥锁

    def process1(self):
        with QMutexLocker(self.mutex1):  # 获取第一个锁
            print("Process 1: Mutex 1 locked")
            QThread.msleep(100)  # 模拟处理时间
            with QMutexLocker(self.mutex2):  # 获取第二个锁
                print("Process 1: Mutex 2 locked")

    def process2(self):
        with QMutexLocker(self.mutex2):  # 获取第二个锁
            print("Process 2: Mutex 2 locked")
            QThread.msleep(100)  # 模拟处理时间
            with QMutexLocker(self.mutex1):  # 获取第一个锁
                print("Process 2: Mutex 1 locked")

class WorkerThread(QThread):
    def __init__(self, shared_resource, process_func):
        super().__init__()
        self.shared_resource = shared_resource
        self.process_func = process_func

    def run(self):
        self.process_func()

if __name__ == "__main__":
    shared_resource = SharedResource()

    thread1 = WorkerThread(shared_resource, shared_resource.process1)
    thread2 = WorkerThread(shared_resource, shared_resource.process2)

    thread1.start()  # 启动线程1
    thread2.start()  # 启动线程2

    thread1.wait()  # 等待线程1完成
    thread2.wait()  # 等待线程2完成

    print("Main thread exited")  # 主线程退出

在这个示例中，两个线程分别尝试获取两个不同的锁（mutex1和mutex2）。通过始终以相同的顺序获取锁，可以避免死锁。同时，通过在获取锁时使用QMutexLocker，可以确保线程在离开作用域时释放锁。

需要注意的是，死锁和线程饥饿是复杂的问题，可能在更复杂的场景中出现。避免死锁和线程饥饿需要仔细的设计和测试，以确保线程在协同工作时能够正确地进行同步和协调。

QMutex 和 QMutexLocker

QMutex 和 QMutexLocker 是 PyQt 中用于线程同步的两个重要类。它们帮助确保多个线程在访问共享资源时的正确同步，以避免竞争条件和数据不一致。下面是关于它们的详解和示例：

QMutex（互斥锁）： 互斥锁是一种线程同步机制，用于控制多个线程对共享资源的访问。在多线程环境中，一个线程可以获得互斥锁的所有权，从而可以安全地访问共享资源。其他线程在获取互斥锁之前必须等待，以确保同一时间只有一个线程可以访问共享资源。

示例代码：

python 复制代码

from PyQt6.QtCore import QMutex

mutex = QMutex()

def thread_function():
    mutex.lock()
    # 访问共享资源
    mutex.unlock()

# 创建多个线程，每个线程执行 thread_function

QMutexLocker（互斥锁锁定器）： QMutexLocker 是 QMutex 的一个辅助类，它在创建时自动锁定 QMutex，并在销毁时释放锁。这样可以确保在一个作用域内，线程在获取锁后能够正确地释放锁，从而避免忘记释放锁而导致的死锁。

示例代码：

python 复制代码

from PyQt6.QtCore import QMutex, QMutexLocker

mutex = QMutex()

def thread_function():
    with QMutexLocker(mutex):  # 进入作用域时自动锁定，离开作用域时自动释放
        # 访问共享资源

# 创建多个线程，每个线程执行 thread_function

在使用 QMutexLocker 时，当线程离开作用域（例如使用 with 语句），会自动释放锁，无论是否发生异常。

【100天精通python】Day38：GUI界面编程_PyQt 从入门到实战（中）_数据库操作与多线程编程

专栏导读

4 数据库操作

4.1 连接数据库

4.2 执行 SQL 查询和更新：

4.3 使用模型和视图显示数据

5 多线程编程

5.1 多线程编程的概念和优势

5.2 在 PyQt 中使用多线程

5.3 处理多线程间的同步和通信问题

5.3.1 信号槽机制

5.3.2 线程安全的数据访问

5.4 避免死锁和线程饥饿

QMutex 和 QMutexLocker