多线程用同一个函数

如果多个线程需要同时执行同一个函数，可以使用线程锁（mutex）来保证线程安全。线程锁可以确保在同一时间只有一个线程可以访问该函数，避免多个线程同时修改同一个变量或数据结构导致的竞态条件和数据不一致的问题。

下面是一个使用线程锁的示例代码：

import threading

# 定义一个全局的锁
lock = threading.Lock()

# 要执行的函数
def my_function():
    # 获取锁
    lock.acquire()
    try:
        # 执行需要保护的代码
        print("Hello, world!")
    finally:
        # 释放锁
        lock.release()

# 创建多个线程并启动
for i in range(10):
    t = threading.Thread(target=my_function)
    t.start()

在上面的代码中，我们定义了一个全局的锁对象，然后在需要保护的代码块中先获取锁，执行完后再释放锁。这样就可以保证同一时间只有一个线程可以执行该函数，避免了竞态条件和数据不一致的问题。

相关问题

多线程用同一个函数C语言demo

以下是一个使用多线程调用同一个函数的C语言示例代码：

#include <stdio.h>
#include <pthread.h>

void* thread_func(void* arg) {
    int thread_num = *(int*)arg;

    // 执行一些线程任务
    printf("Thread %d is running\n", thread_num);
    
    return NULL;
}

int main() {
    int num_threads = 5;
    pthread_t threads[num_threads];

    // 创建多个线程
    for (int i = 0; i < num_threads; i++) {
        int* thread_num = malloc(sizeof(int));
        *thread_num = i;
        pthread_create(&threads[i], NULL, thread_func, thread_num);
    }

    // 等待所有线程执行完毕
    for (int i = 0; i < num_threads; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

在这个示例中，我们创建了5个线程，并使用`pthread_create()`函数启动它们。每个线程都调用`thread_func()`函数来执行一些任务，这个函数接收一个整数参数`thread_num`，表示当前线程的编号。在这个示例中，`thread_func()`函数只是简单地打印出当前线程的编号，以证明这些线程在同时运行。

最后，我们使用`pthread_join()`函数等待所有线程执行完毕，然后退出程序。

qt多线程同时执行三个函数并传参

你可以使用Qt的QThread类和信号与槽机制来实现多线程同时执行三个函数并传参的功能。

首先，定义一个继承自QThread的线程类，例如：

class MyThread : public QThread
{
    Q_OBJECT

public:
    explicit MyThread(QObject *parent = nullptr);
    void run() override;

signals:
    void resultReady(const QString &result);

private:
    // 定义需要传递的参数
    QString m_param;
};

在该类中，我们定义了一个需要传递的参数m_param，并在run函数中执行需要执行的函数，并通过信号resultReady将执行结果传递出来。

接下来，在主线程中创建三个MyThread对象并启动它们，例如：

MyThread *thread1 = new MyThread(this);
thread1->m_param = "param1";
connect(thread1, &MyThread::resultReady, this, [](const QString &result){
    qDebug() << "Thread1 Result: " << result;
});
thread1->start();

MyThread *thread2 = new MyThread(this);
thread2->m_param = "param2";
connect(thread2, &MyThread::resultReady, this, [](const QString &result){
    qDebug() << "Thread2 Result: " << result;
});
thread2->start();

MyThread *thread3 = new MyThread(this);
thread3->m_param = "param3";
connect(thread3, &MyThread::resultReady, this, [](const QString &result){
    qDebug() << "Thread3 Result: " << result;
});
thread3->start();

在创建三个线程对象并启动它们的过程中，我们将需要传递的参数m_param分别设置为"param1"、"param2"和"param3"，并通过connect函数将resultReady信号与对应的槽函数连接起来。

最后，在MyThread类的run函数中执行需要执行的函数，并将执行结果通过resultReady信号传递出来，例如：

void MyThread::run()
{
    // 执行需要执行的函数
    QString result = myFunction(m_param);

    // 将执行结果通过信号传递出来
    emit resultReady(result);
}

其中，myFunction函数为需要执行的函数，通过传递的参数m_param来获取需要的参数。执行结果通过resultReady信号传递出来。

注意：在使用多线程时需要注意线程安全的问题，尤其是在多个线程同时访问同一个资源时，需要保证对该资源的访问是互斥的。可以使用Qt的QMutex类来实现互斥访问。