《十八》QThread多线程组件

本章将重点介绍如何运用QThread组件实现多线程功能。

多线程技术在程序开发中尤为常用，Qt框架中提供了QThread库来实现多线程功能。当你需要使用QThread时，需包含QThread模块，以下是QThread类的一些主要成员函数和槽函数。

成员函数/槽函数   

描述
QThread(QObject *parent = nullptr)    构造函数，创建一个QThread对象。
~QThread()    析构函数，释放QThread对象。
void start(QThread::Priority priority = InheritPriority)    启动线程。
void run()    默认的线程执行函数，需要在继承QThread的子类中重新实现以定义线程的操作。
void exit(int returnCode = 0)    请求线程退出，线程将在适当的时候退出。
void quit()   请求线程退出，与exit()类似。
void terminate()   立即终止线程的执行。这是一个危险的操作，可能导致资源泄漏和未完成的操作。
void wait()   等待线程完成。主线程将被阻塞，直到该线程退出。
bool isRunning() const    检查线程是否正在运行。
void setPriority(Priority priority)    设置线程的优先级。
Priority priority() const   获取线程的优先级。
QThread::Priority priority()    获取线程的优先级。
void setStackSize(uint stackSize)    设置线程的堆栈大小（以字节为单位）。
uint stackSize() const   获取线程的堆栈大小。
void msleep(unsigned long msecs)    使线程休眠指定的毫秒数。
void sleep(unsigned long secs)    使线程休眠指定的秒数。
static QThread *currentThread()   获取当前正在执行的线程的QThread对象。
void setObjectName(const QString &name)    为线程设置一个对象名。

当我们需要创建线程时，通常第一步则是要继承QThread类，并重写类内的run()方法，在run()方法中，你可以编写需要在新线程中执行的代码。当你创建一个QThread的实例并调用它的start()方法时，会自动调用run()来执行线程逻辑，如下这样一段代码展示了如何运用线程类。

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

class MyThread : public QThread
{
public:
    void run() override
    {
        for (int i = 0; i < 5; ++i)
        {
            qDebug() << "Thread is running" << i;
            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread;
    thread.start();
    thread.wait();

    qDebug() << "Main thread is done.";
    return a.exec();
}

上述代码运行后则会每隔1秒输出一段话，在主函数内通过调用thread.start方法启动这个线程，并通过thread.wait等待线程结束，如下图所示；

1.1 线程组与多线程 

        线程组是一种组织和管理多个线程的机制，允许将相关联的线程集中在一起，便于集中管理、协调和监控。通过线程组，可以对一组线程进行统一的生命周期管理，包括启动、停止、调度和资源分配等操作。

        上述方法并未真正实现多线程功能，我们继续完善MyThread自定义类，在该类内增加两个标志，is_run()用于判断线程是否正在运行，is_finish()则用来判断线程是否已经完成，并在run()中增加打印当前线程对象名称的功能。

class MyThread: public QThread
{
protected:
    volatile bool m_to_stop;

protected:
    void run()
    {
        for(int x=0; !m_to_stop && (x <10); x++)
        {
            msleep(1000);
            std::cout << objectName().toStdString() << std::endl;
        }
    }

public:
    MyThread()
    {
        m_to_stop = false;
    }

    void stop()
    {
        m_to_stop = true;
    }

    void is_run()
    {
        std::cout << "Thread Running = " << isRunning() << std::endl;
    }

    void is_finish()
    {
        std::cout << "Thread Finished = " << isFinished() << std::endl;
    }

};

接着在主函数内调整，增加一个MyThread thread[10]用于存储线程组，线程组是一种用于组织和管理多个线程的概念。在不同的编程框架和操作系统中，线程组可能具有不同的实现和功能，但通常用于提供一种集中管理和协调一组相关线程的机制。

我们通过循环的方式依次对线程组进行赋值，通过调用setObjectName对每一个线程赋予一个不同的名称，当需要使用这些线程时则可以通过循环调用run()方法来实现，而结束调用同样如此，如下是调用的具体实现；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 定义线程数组
    MyThread thread[10];

    // 设置线程对象名字
    for(int x=0;x<10;x++)
    {
        thread[x].setObjectName(QString("thread => %1").arg(x));
    }

    // 批量调用run执行
    for(int x=0;x<10;x++)
    {
        thread[x].start();
        thread[x].is_run();
        thread[x].isFinished();
    }

    // 批量调用stop关闭
    for(int x=0;x<10;x++)
    {
        thread[x].wait();
        thread[x].stop();

        thread[x].is_run();
        thread[x].is_finish();
    }

    return a.exec();
}

如下图则是运行后实现的多线程效果；

1.2 向线程中传递参数 

向线程中传递参数是多线程编程中常见的需求，不同的编程语言和框架提供了多种方式来实现这个目标，在Qt中，由于使用的自定义线程类，所以可通过增加一个set_value()方法来向线程内传递参数，由于线程函数内的变量使用了protected属性，所以也就实现了线程间变量的隔离，当线程被执行结束后则可以通过result()方法获取到线程执行结果，这个线程函数如下所示；

class MyThread: public QThread
{
protected:
    int m_begin;
    int m_end;
    int m_result;

    void run()
    {
        m_result = m_begin + m_end;
    }

public:
    MyThread()
    {
        m_begin = 0;
        m_end = 0;
        m_result = 0;
    }

    // 设置参数给当前线程
    void set_value(int x,int y)
    {
        m_begin = x;
        m_end = y;
    }

    // 获取当前线程名
    void get_object_name()
    {
        std::cout << "this thread name => " << objectName().toStdString() << std::endl;
    }

    // 获取线程返回结果
    int result()
    {
        return m_result;
    }
};

在主函数中，我们通过MyThread thread[3];来定义3个线程组，并通过循环三次分别thread[x].set_value()设置三组不同的参数，当设置完成后则可以调用thread[x].start()方法运行这些线程，线程运行结束后则返回值将会被依次保存在thread[x].result()中，此时直接将其相加即可得到最终线程执行结果；

#include <QCoreApplication>
#include <iostream>
#include <QThread>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyThread thread[3];

    // 分别将不同的参数传入到线程函数内
    for(int x=0; x<3; x++)
    {
        thread[x].set_value(1,2);
        thread[x].setObjectName(QString("thread -> %1").arg(x));
        thread[x].start();
    }

    // 等待所有线程执行结束
    for(int x=0; x<3; x++)
    {
        thread[x].get_object_name();
        thread[x].wait();
    }

    // 获取线程返回值并相加
    int result = thread[0].result() + thread[1].result() + thread[2].result();
    std::cout << "sum => " << result << std::endl;

    return a.exec();
}

 程序运行后，则可以输出三个线程相加的和；

1.3 互斥同步线程锁

QMutex 是Qt框架中提供的用于线程同步的类，用于实现互斥访问共享资源。Mutex是“互斥锁（Mutual Exclusion）”的缩写，它能够确保在任意时刻，只有一个线程可以访问被保护的资源，从而避免了多线程环境下的数据竞争和不一致性。

在Qt中，QMutex提供了简单而有效的线程同步机制，其基本用法包括：

  •     锁定（Lock）： 线程在访问共享资源之前，首先需要获取QMutex的锁，这通过调用lock()方法来实现。
  •     解锁（Unlock）： 当线程使用完共享资源后，需要释放QMutex的锁，以允许其他线程访问，这通过调用unlock()方法来实现。

该锁lock()锁定与unlock()解锁必须配对使用，线程锁保证线程间的互斥，利用线程锁能够保证临界资源的安全性。

  • 线程锁解决的问题: 多个线程同时操作同一个全局变量，为了防止资源的无序覆盖现象，从而需要增加锁，来实现多线程抢占资源时可以有序执行。
  • 临界资源(Critical Resource): 每次只允许一个线程进行访问 (读/写)的资源。
  • 线程间的互斥(竞争): 多个线程在同一时刻都需要访问临界资源。
  • 一般性原则: 每一个临界资源都需要一个线程锁进行保护。

我们以生产者消费者模型为例来演示锁的使用方法，生产者消费者模型是一种并发编程中常见的同步机制，用于解决多线程环境下的协作问题。该模型基于两类角色：生产者（Producer）和消费者（Consumer），它们通过共享的缓冲区进行协作。

生产者消费者模型的典型应用场景包括异步任务处理、事件驱动系统、数据缓存等。这种模型的实现可以通过多线程编程或使用消息队列等方式来完成。

首先在全局中引入#include <QMutex>库，并在全局定义static QMutex线程锁变量，接着我们分别定义两个自定义线程函数，其中Producer代表生产者，而Customer则是消费者，生产者中负责每次产出一个随机数并将其追加到g_store全局变量内保存，消费者则通过g_store.remove每次取出一个元素。

static QMutex g_mutex;      // 线程锁
static QString g_store;     // 定义全局变量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 加锁
            g_mutex.lock();

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            // 释放锁
            g_mutex.unlock();
            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            g_mutex.lock();
            if( g_store != "" )
            {
                g_store.remove(0, 1);
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            g_mutex.unlock();
            msleep(1000);
        }
    }
};

在主函数中分别定义两个线程类，并依次运行它们；

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p;
    Customer c;

    p.setObjectName("producer");
    c.setObjectName("curstomer");

    p.start();
    c.start();

    return a.exec();
}

至此，生产者产生数据，消费者消费数据；如下图所示；

QMutexLocker 是Qt框架中提供的一个辅助类，它是在QMutex基础上简化版的线程锁，QMutexLocker会保护加锁区域，并自动实现互斥量的锁定和解锁操作，可以将其理解为是智能版的QMutex锁，通过 QMutexLocker可以确保在作用域内始终持有锁，从而避免因为忘记释放锁而导致的问题。该锁只需要在上方代码中稍加修改即可。

使用 QMutexLocker 的一般流程如下：

  1. 创建一个 QMutex 对象。
  2. 创建一个 QMutexLocker 对象，传入需要锁定的 QMutex。
  3. 在 QMutexLocker 对象的作用域内进行需要互斥访问的操作。
  4. 当 QMutexLocker 对象超出作用域范围时，会自动释放锁。
static QMutex g_mutex;      // 线程锁
static QString g_store;     // 定义全局变量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
			// 增加智能线程锁
            QMutexLocker Locker(&g_mutex);

            g_store.append(QString::number((count++) % 10));
            std::cout << "Producer -> "<< g_store.toStdString() << std::endl;

            msleep(900);
        }
    }
};

 1.4 读写同步线程锁

QReadWriteLock 是Qt框架中提供的用于实现读写锁的类。读写锁允许多个线程同时读取共享数据，但在写入数据时会互斥，确保数据的一致性和完整性。这对于大多数情况下读取频繁而写入较少的共享数据非常有用，可以提高程序的性能。

其提供了两种锁定操作：

  • 读取锁（Read Lock）： 允许多个线程同时获取读取锁，用于并行读取共享数据。在没有写入锁的情况下，多个线程可以同时持有读取锁。
  • 写入锁（Write Lock）： 写入锁是互斥的，当一个线程获取写入锁时，其他线程无法获取读取锁或写入锁。这确保了在写入数据时，不会有其他线程同时读取或写入。

互斥锁存在一个问题，每次只能有一个线程获得互斥量的权限，如果在程序中有多个线程来同时读取某个变量，那么使用互斥量必须排队，效率上会大打折扣，基于QReadWriteLock读写模式进行代码段锁定，即可解决互斥锁存在的问题。

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QMutex>
#include <QReadWriteLock>

static QReadWriteLock g_mutex;      // 线程锁
static QString g_store;             // 定义全局变量

class Producer : public QThread
{
protected:
    void run()
    {
        int count = 0;

        while(true)
        {
            // 以写入方式锁定资源
            g_mutex.lockForWrite();

            g_store.append(QString::number((count++) % 10));

            // 写入后解锁资源
            g_mutex.unlock();

            msleep(900);
        }
    }
};

class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 以读取方式写入资源
            g_mutex.lockForRead();
            if( g_store != "" )
            {
                std::cout << "Curstomer -> "<< g_store.toStdString() << std::endl;
            }

            // 读取到后解锁资源
            g_mutex.unlock();
            msleep(1000);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1,p2;
    Customer c1,c2;

    p1.setObjectName("producer 1");
    p2.setObjectName("producer 2");

    c1.setObjectName("curstomer 1");
    c2.setObjectName("curstomer 2");

    p1.start();
    p2.start();

    c1.start();
    c2.start();

    return a.exec();
}

 该锁允许用户以同步读lockForRead()或同步写lockForWrite()两种方式实现保护资源，但只要有一个线程在以写的方式操作资源，其他线程也会等待写入操作结束后才可继续读资源。

1.5 基于信号线程锁

QSemaphore 是Qt框架中提供的用于实现信号量的类。信号量是一种用于在线程之间进行同步和通信的机制，它允许多个线程在某个共享资源上进行协调，控制对该资源的访问。QSemaphore 的主要作用是维护一个计数器，线程可以通过获取和释放信号量来改变计数器的值。

其主要方法包括：

  • QSemaphore(int n = 0)：构造函数，创建一个初始计数值为 n 的信号量。
  • void acquire(int n = 1)：获取信号量，将计数器减去 n。如果计数器不足，线程将阻塞等待。
  • bool tryAcquire(int n = 1)：尝试获取信号量，如果计数器足够，立即获取并返回 true；否则返回 false。
  • void release(int n = 1)：释放信号量，将计数器加上 n。如果有等待的线程，其中一个将被唤醒。

信号量是特殊的线程锁，信号量允许N个线程同时访问临界资源，通过acquire()获取到指定资源，release()释放指定资源。

#include <QCoreApplication>
#include <iostream>
#include <QThread>
#include <QSemaphore>

const int SIZE = 5;
unsigned char g_buff[SIZE] = {0};

QSemaphore g_sem_free(SIZE); // 5个可生产资源
QSemaphore g_sem_used(0);    // 0个可消费资源

// 生产者生产产品
class Producer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            int value = qrand() % 256;

            // 若无法获得可生产资源，阻塞在这里
            g_sem_free.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( !g_buff[i] )
                {
                    g_buff[i] = value;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可消费资源数+1
            g_sem_used.release();

            sleep(2);
        }
    }
};

// 消费者消费产品
class Customer : public QThread
{
protected:
    void run()
    {
        while( true )
        {
            // 若无法获得可消费资源，阻塞在这里
            g_sem_used.acquire();

            for(int i=0; i<SIZE; i++)
            {
                if( g_buff[i] )
                {
                    int value = g_buff[i];

                    g_buff[i] = 0;
                    std::cout << objectName().toStdString() << " --> " << value << std::endl;
                    break;
                }
            }

            // 可生产资源数+1
            g_sem_free.release();

            sleep(1);
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer p1;
    Customer c1;

    p1.setObjectName("producer");
    c1.setObjectName("curstomer");

    p1.start();
    c1.start();

    return a.exec();
}

 本篇原作者链接：C++ Qt开发：运用QThread多线程组件_c++ qt qthread-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/599992.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux内核之获取文件系统超级块:sget用法实例(六十八)

Linux内核之获取文件系统超级块:sget用法实例(六十八)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
EMAIL-PHP功能齐全的发送邮件类可以发送HTML和附件

EMAIL-PHP功能齐全的发送邮件类可以发送HTML和附件

EMAIL-PHP功能齐全的发送邮件类可以发送HTML和附件 <?php class Email { //---设置全局变量 var $mailTo ""; // 收件人 var $mailCC ""; // 抄送 var $mailBCC ""; // 秘密抄送 var $mailFrom ""; // 发件人 var $mailSubje…
阅读更多...
如何查看慢查询

如何查看慢查询

4.2 如何查看慢查询 知道了以上内容之后&#xff0c;那么咱们如何去查看慢查询日志列表呢&#xff1a; slowlog len&#xff1a;查询慢查询日志长度slowlog get [n]&#xff1a;读取n条慢查询日志slowlog reset&#xff1a;清空慢查询列表 5、服务器端优化-命令及安全配置 安…
阅读更多...
6.Nginx

6.Nginx

Nginx反向代理 将前端发送的动态请求有Nginx转发到后端服务器 那为何要多一步转发而不直接发送到后端呢&#xff1f; 反向代理的好处&#xff1a; 提高访问速度&#xff08;可以在nginx做缓存&#xff0c;如果请求的是同样的接口地址&#xff0c;这样就不用多次请求后端&#…
阅读更多...
本地运行AI大模型简单示例

本地运行AI大模型简单示例

一、引言 大模型LLM英文全称是Large Language Model&#xff0c;是指包含超大规模参数&#xff08;通常在十亿个以上&#xff09;的神经网络模型。2022年11月底&#xff0c;人工智能对话聊天机器人ChatGPT一经推出&#xff0c;人们利用ChatGPT这样的大模型帮助解决很多事情&am…
阅读更多...
AUTOSAR中EcuM、ComM和CanNm的关联

AUTOSAR中EcuM、ComM和CanNm的关联

ComM的内外部唤醒 ComM可以通过NM保持网络的唤醒&#xff0c;同时也可以通过SM激活通信&#xff0c;总之就像一个通信的总管。 下面通过两种唤醒源来解释ComM的状态机。 1、内部唤醒 ① 当ComM上电初始化时会首先进入NO COMMUNICATION状态&#xff0c;在该状态下ComM会持续循…
阅读更多...
Linux学习之路 -- 文件 -- 文件描述符

Linux学习之路 -- 文件 -- 文件描述符

前面介绍了与文件相关的各种操作&#xff0c;其中的各个接口都离不开一个整数&#xff0c;那就是文件描述符&#xff0c;本文将介绍文件描述符的一些相关知识。 目录 <1>现象 <2>原理 文件fd的分配规则和利用规则实现重定向 <1>现象 我们可以先通过prin…
阅读更多...
如何根据IP获取国家省份城市名称PHP免费版

如何根据IP获取国家省份城市名称PHP免费版

最近项目遇到需要根据IP获取用户国家功能需求&#xff0c;网上找了一下&#xff0c;很多API接口都需要付费&#xff0c;考虑为公司节约成本&#xff0c;就取找找有没有开源的 github 上面那个包含多种语言&#xff0c;下面这个只有php&#xff0c;用法很简单 $ip 114.114.114…
阅读更多...
视频素材哪个app好？8个视频素材库免费使用

视频素材哪个app好？8个视频素材库免费使用

视频内容已成为现代传播中不可或缺的一部分&#xff0c;具备卓越的视频素材对于提升任何媒体作品的质量和吸引力尤为关键。这里列举的一系列精挑细选的全球视频素材网站&#xff0c;旨在为您的商业广告、社交媒体更新或任何其他类型的视觉项目提供最佳支持。 1. 蛙学府&#x…
阅读更多...
数据结构复习/学习9--二叉树

数据结构复习/学习9--二叉树

一、堆与完全二叉树 1.堆的逻辑与物理结构 2.父节点与子节点的下标 3.大小根堆 二、堆的实现&#xff08;大根堆为例&#xff09; 注意事项总结&#xff1a; 注意堆中插入与删除数据的位置和方法与维持大根堆有序时的数据上下调整 三、堆排序 1.排升序建大堆效率高 注意事项…
阅读更多...
VUE v-for 数据引用

VUE v-for 数据引用

VUE 的数据引用有多种方式。 直接输出数据 如果我们希望页面中直接输出数据就可以使用&#xff1a; {{ pageNumber }}双括号引用的方式即可。 在 JavaScript 中引用 如果你需要直接在代码中使用&#xff0c;直接使用变量名就可以了。 上面这张小图&#xff0c;显示了引用的…
阅读更多...
【计组OS】访存过程以及存储层次化结构

【计组OS】访存过程以及存储层次化结构

苏泽 本专栏纯个人笔记作用 用于记录408 学习的笔记记录&#xff08;敲了两年码实在不习惯手写笔记了&#xff09; 如果能帮助到大家当然最好 但由于是工作后退下来备考 很多说法和想法都会结合实际开发的思想 可能不是那么的纯粹应试哈 希望大家挑选自己喜欢的口味食用…
阅读更多...
纯血鸿蒙APP实战开发——自定义安全键盘案例

纯血鸿蒙APP实战开发——自定义安全键盘案例

介绍 金融类应用在密码输入时&#xff0c;一般会使用自定义安全键盘。本示例介绍如何使用TextInput组件实现自定义安全键盘场景&#xff0c;主要包括TextInput.customKeyboard绑定自定义键盘、自定义键盘布局和状态更新等知识点。 效果图预览 实现思路 1. 使用TextInput的cu…
阅读更多...
解决本地启动项目，用IP地址访问失败问题

解决本地启动项目，用IP地址访问失败问题

解决方法&#xff1a;看看index.html页面有没有 这个标签&#xff0c;将它注释掉
阅读更多...
Mybatis的简介和下载安装

Mybatis的简介和下载安装

什么是 MyBatis &#xff1f; MyBatis 是一款优秀的持久层框架&#xff0c;它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息&#xff0c;将接口和 Java 的…
阅读更多...
Vue3基础笔记（4）组件

Vue3基础笔记（4）组件

目录 一.模版引用 二.组件组成 1.引入组件 2.注入组件 3.显示组件 三.组件嵌套关系 四.组件注册方式 五.组件传递数据 六.组件事件 一.模版引用 虽然Vue的声明性渲染模型为你抽象了大部分对DOM的直接操作&#xff0c;但在某些情况下&#xff0c;我们仍然需要直接访问底…
阅读更多...
30分钟打造属于自己的Flutter内存泄漏检测工具---FlutterLeakCanary

30分钟打造属于自己的Flutter内存泄漏检测工具---FlutterLeakCanary

30分钟打造属于自己的Flutter内存泄漏检测工具 思路检测Dart 也有弱引用-----WeakReference如何执行Full GC&#xff1f;如何知道一个引用他的文件路径以及类名&#xff1f; 代码实践第一步&#xff0c;实现Full GC第二步&#xff0c;如何根据对象引用&#xff0c;获取出他的类…
阅读更多...
Python运维-日志记录、FTP、邮件提醒

Python运维-日志记录、FTP、邮件提醒

本章目录如下&#xff1a; 五、日志记录 5.1、日志模块简介 5.2、logging模块的配置与使用 六、搭建FTP服务器与客户端 6.1、FTP服务器模式 6.2、搭建服务器 6.3、编写FTP客户端程序 七、邮件提醒 7.1、发送邮件 7.2、接收邮件 7.3、实例&#xff1a;将报警信息实时…
阅读更多...
【系统架构师】-选择题（十四）

【系统架构师】-选择题（十四）

1、某企业开发信息管理系统平台进行 E-R 图设计&#xff0c;人力部门定义的是员工实体具有属性&#xff1a;员工号、姓名、性别、出生日期、联系方式和部门,培训部门定义的培训师实体具有属性:培训师号&#xff0c;姓名和职称&#xff0c;其中职称{初级培训师&#xff0c;中级培…
阅读更多...
【每日刷题】Day33

【每日刷题】Day33

【每日刷题】Day33 &#x1f955;个人主页&#xff1a;开敲&#x1f349; &#x1f525;所属专栏&#xff1a;每日刷题&#x1f34d; &#x1f33c;文章目录&#x1f33c; 1. 20. 有效的括号 - 力扣&#xff08;LeetCode&#xff09; 2. 445. 两数相加 II - 力扣&#xff08;…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站