linux线程主动切换的方法

在Linux中，线程主动切换主要有以下几种方法：

一、基于条件变量（pthread_cond_wait / pthread_cond_signal）

基础概念
- 条件变量是一种同步机制，用于线程间的协作。当一个线程等待某个条件满足时，它可以调用pthread_cond_wait进入等待状态，此时线程会释放它所持有的互斥锁（通常与条件变量一起使用来保护共享数据），并进入阻塞状态。当另一个线程使条件满足时，它可以调用pthread_cond_signal或者pthread_cond_broadcast来唤醒等待的线程。

优势
- 避免忙等待，节省CPU资源。因为等待线程在条件不满足时不会不断地循环检查条件，而是进入阻塞状态。
- 能够精确控制线程的唤醒，pthread_cond_signal只会唤醒一个等待线程，而pthread_cond_broadcast会唤醒所有等待线程。
应用场景
- 生产者 - 消费者模型。例如，生产者线程生产数据，当缓冲区满时，生产者线程等待（pthread_cond_wait）；消费者线程消费数据，当缓冲区空时，消费者线程等待。当生产者生产了新的数据或者消费者消费了数据后，通过pthread_cond_signal或pthread_cond_broadcast来通知等待的线程。
示例代码

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

pthread_mutex_t mutex;
pthread_cond_t cond;
int data = 0;

void* producer(void* arg) {
    for (int i = 0; i < 5; i++) {
        pthread_mutex_lock(&mutex);
        while (data == 1) {
            pthread_cond_wait(&cond, &mutex);
        }
        data = 1;
        printf("Producer produced data
");
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 5; i++) {
        pthread_mutex_lock(&mutex);
        while (data == 0) {
            pthread_cond_wait(&cond, &mutex);
        }
        data = 0;
        printf("Consumer consumed data
");
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

二、基于信号量（semaphore）

基础概念
- 信号量是一个整型变量，用于控制多个线程对共享资源的访问。它可以用来实现线程间的同步和互斥。例如，当一个线程想要访问某个资源时，它首先检查信号量的值，如果值大于0，则表示资源可用，线程可以访问并将信号量减1；如果值为0，则线程需要等待，直到其他线程释放资源（增加信号量的值）。

优势
- 可以控制对有限数量资源的并发访问数量。例如，如果有3个数据库连接池资源，可以使用信号量来确保最多只有3个线程同时使用这些资源。
- 简单直观的同步机制，适用于多种场景下的线程协作。
应用场景
- 资源池管理，如数据库连接池、线程池等的管理。
- 多线程任务的分段执行，当一个线程完成一部分任务后，通过信号量通知其他线程开始下一阶段的任务。
示例代码（使用POSIX信号量）

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

sem_t sem;
int shared_data = 0;

void* thread1(void* arg) {
    for (int i = 0; i < 3; i++) {
        sem_wait(&sem);
        shared_data++;
        printf("Thread1: shared_data = %d
", shared_data);
        sem_post(&sem);
        sleep(1);
    }
    return NULL;
}

void* thread2(void* arg) {
    for (int i = 0; i < 3; i++) {
        sem_wait(&sem);
        shared_data--;
        printf("Thread2: shared_data = %d
", shared_data);
        sem_post(&sem);
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    sem_init(&sem, 0, 1);
    pthread_create(&t1, NULL, thread1, NULL);
    pthread_create(&t2, NULL, thread2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    sem_destroy(&sem);
    return 0;
}

三、主动让出CPU（sched_yield）

基础概念
- sched_yield函数允许当前线程主动让出CPU资源，使得调度器可以调度其他就绪状态的线程运行。这并不一定会导致线程进入阻塞状态，只是让出当前的CPU时间片。

优势
- 在某些情况下，可以提高系统的整体性能和响应性。例如，当一个线程发现自己暂时不需要继续执行（可能是因为等待某个即将到来的事件，但目前还没有发生），可以让出CPU给其他线程，避免不必要的CPU占用。
应用场景
- 在实时性要求较高的系统中，当线程预测到自己可能需要等待一段时间时，可以使用sched_yield来优化系统的调度。
- 在多线程协作任务中，当一个线程完成了自己当前阶段的小任务，但整体任务还未完成时，可以让出CPU给其他相关线程。
示例代码

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

void* thread_func(void* arg) {
    for (int i = 0; i < 5; i++) {
        printf("Thread running iteration %d
", i);
        sched_yield();
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    pthread_join(thread, NULL);
    return 0;
}

四、线程休眠（sleep / usleep）

基础概念
- sleep函数使当前线程暂停执行指定的秒数，usleep使线程暂停执行指定的微秒数。这是一种简单的让线程主动停止执行一段时间的方法，在这段时间内，线程会让出CPU资源给其他线程。

优势
- 简单易用，在一些对时间精度要求不是非常高的场景下，可以快速实现线程的暂停。
应用场景
- 定时任务中，在每次任务执行间隔期间让线程休眠。例如，每隔10秒检查一次系统资源使用情况，线程在每次检查后休眠10秒。
- 模拟一些需要时间间隔的操作，如在网络通信中模拟数据传输的延迟。
示例代码

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

void* thread_func(void* arg) {
    for (int i = 0; i < 3; i++) {
        printf("Thread sleeping iteration %d
", i);
        sleep(2);
    }
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    pthread_join(thread, NULL);
    return 0;
}

如果遇到线程切换相关的问题：

一、死锁问题（可能与线程切换机制相关）