linux下c语言的多线程编程

在Linux环境下，C语言的多线程编程是非常常见的一种方式，因为它可以有效地提高程序的并发性、响应性和性能，并且它非常适合运行在多处理器和多核的计算机上。本文将向您介绍如何在Linux下使用C语言编写多线程程序。

1.线程原理

线程是操作系统中能够运行的最小的单位，它可以与其他线程共享同一个进程的地址空间、文件和I/O等资源。每个线程有自己的堆栈和线程控制块，其中包括线程ID、线程状态、优先级等信息。

线程的优点在于它的启动、线程切换、体积等方面比进程更轻量级，这使得线程更加适合用于并发和并行计算。例如，当在一个时刻上有多个任务需要执行时，每个任务可以分配一个线程来处理，从而可以提高整体系统性能。

2.线程的创建和销毁

在Linux中，可以使用pthread库以及其提供的线程API来创建和销毁线程。下面是一个简单的线程创建和销毁的例子：

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

void* thread_func(void *arg)
{
    int i;
    for (i = 0; i < 10; i++) {
        printf("Thread %d: %d
", *((int*) arg), i);
    }
    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t threads[2];
    int t1 = 1, t2 = 2;
    printf("Main thread started...
");
    pthread_create(&threads[0], NULL, thread_func, &t1);
    pthread_create(&threads[1], NULL, thread_func, &t2);
    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);
    printf("Main thread end.
");
    return 0;
}

在这个例子中，我们定义了一个名为thread_func的函数，它将作为一个线程运行。在主线程中，我们创建了两个线程并将它们分别传递给线程函数thread_func进行处理。最后，我们等待所有线程都完成后才结束主线程。

3.线程同步和互斥

当多个线程同时访问共享资源时，有可能会发生竞态条件和死锁等问题。为了避免这些问题，我们需要使用线程同步和互斥机制。在Linux中，可以使用互斥量和条件变量来实现这些机制。下面是一个使用互斥量的例子：

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

#define MAX 10

int count = 0;
pthread_mutex_t mutex;

void* thread_func(void *arg)
{
    int i;
    for (i = 0; i < MAX; i++) {
        pthread_mutex_lock(&mutex);
        count++;
        printf("Thread %d: count = %d
", *((int*) arg), count);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t threads[2];
    int t1 = 1, t2 = 2;
    printf("Main thread started...
");
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&threads[0], NULL, thread_func, &t1);
    pthread_create(&threads[1], NULL, thread_func, &t2);
    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);
    pthread_mutex_destroy(&mutex);
    printf("Main thread end.
");
    return 0;
}

在这个例子中，我们定义了一个名为count的全局变量，它将被两个线程共享。我们通过调用pthread_mutex_lock和pthread_mutex_unlock来保护对count的访问，从而避免了竞态条件的发生。

4.读写锁

在上述例子中，我们使用了互斥锁来解决线程访问同一个资源的竞争条件。然而，当线程只读访问时使用互斥锁并不是一个很好的选择，因为它会导致读取操作的阻塞。

为了避免这种情况，我们可以使用读写锁。读写锁允许多个线程同时读取同一资源，但是当有一个线程正在写入资源时，所有读线程将被阻塞，以确保写操作在进行时没有任何读取操作。下面是一个使用读写锁的例子：

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

#define MAX 10

int count = 0;
pthread_rwlock_t rwlock;

void* read_func(void *arg)
{
    int i;
    for (i = 0; i < MAX; i++) {
        pthread_rwlock_rdlock(&rwlock);
        printf("Thread %d: read count = %d
", *((int*) arg), count);
        pthread_rwlock_unlock(&rwlock);
    }
    pthread_exit(NULL);
}

void* write_func(void *arg)
{
    int i;
    for (i = 0; i < MAX; i++) {
        pthread_rwlock_wrlock(&rwlock);
        count++;
        printf("Thread %d: write count = %d
", *((int*) arg), count);
        pthread_rwlock_unlock(&rwlock);
    }
    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    pthread_t threads[3];
    int t1 = 1, t2 = 2, t3 = 3;
    printf("Main thread started...
");
    pthread_rwlock_init(&rwlock, NULL);
    pthread_create(&threads[0], NULL, write_func, &t1);
    pthread_create(&threads[1], NULL, read_func, &t2);
    pthread_create(&threads[2], NULL, read_func, &t3);
    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);
    pthread_join(threads[2], NULL);
    pthread_rwlock_destroy(&rwlock);
    printf("Main thread end.
");
    return 0;
}

在这个例子中，我们定义了两个名为read_func和write_func的线程函数。read_func函数使用pthread_rwlock_rdlock获取读锁，而write_func函数使用pthread_rwlock_wrlock获取写锁。这样，当一个线程正在写入资源时，另一个线程只能读取资源，而读取线程将被阻塞，直到写入操作完成。这样，我们就避免了写锁和读锁之间的竞争条件。

5.总结

本文介绍了在Linux环境下使用C语言编写多线程程序的基本知识。在实际应用中，通过合理地使用线程同步和互斥机制，我们可以写出更加健壮和高效的多线程程序，从而提高整体性能。