Linux下C语言使用多线程有哪些不同调度策略，请分别举例

在Linux下，C语言使用多线程时可以使用以下不同的调度策略：

1. SCHED_FIFO（先进先出调度策略）：
- 该调度策略按照线程的优先级顺序进行调度，优先级高的线程先执行，直到该线程主动释放CPU或者被更高优先级的线程抢占。
- 示例代码中使用了SCHED_FIFO调度策略的示例，请参考上一个问题中的代码示例。

2. SCHED_RR（循环调度策略）：
- 该调度策略类似于SCHED_FIFO，不同之处在于每个线程执行一段时间后会被系统自动抢占，以便其他优先级相同或更高的线程有机会执行。
- 示例代码中使用了SCHED_RR调度策略的示例，请参考上一个问题中的代码示例。

3. SCHED_OTHER（默认调度策略）：
- 默认的调度策略，也称为时间片轮转调度策略。
- 系统根据线程的优先级和时间片大小来进行调度，每个线程会按照时间片大小分配一定的CPU时间，超过时间片后就会被抢占。
- 通常情况下，大多数线程使用默认的SCHED_OTHER调度策略。

这些调度策略可以通过`pthread_attr_setschedpolicy`函数设置，示例代码中使用的`pthread_attr_setschedpolicy(&attr, policy)`函数即可设置调度策略。注意，具体的调度策略和优先级可能取决于操作系统和硬件平台的限制。

相关问题

Linux下C语言使用多线程使用不同时间片和不同调度策略举例

在Linux下，C语言使用多线程可以通过pthread库来实现。下面是一个使用不同时间片和不同调度策略的示例：

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

void* increment(void* arg) {
    int i;
    for (i = 0; i < 5; i++) {
        printf("Thread 1: %d\n", i);
    }
    pthread_exit(NULL);
}

void* decrement(void* arg) {
    int i;
    for (i = 5; i > 0; i--) {
        printf("Thread 2: %d\n", i);
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t tid1, tid2;
    pthread_attr_t attr1, attr2;

    // 初始化线程属性
    pthread_attr_init(&attr1);
    pthread_attr_init(&attr2);

    // 设置线程1的时间片大小为10ms
    struct sched_param param1;
    param1.sched_priority = 0;
    pthread_attr_setschedparam(&attr1, &param1);
    pthread_attr_setschedpolicy(&attr1, SCHED_RR); // 使用循环调度策略

    // 设置线程2的时间片大小为20ms
    struct sched_param param2;
    param2.sched_priority = 0;
    pthread_attr_setschedparam(&attr2, &param2);
    pthread_attr_setschedpolicy(&attr2, SCHED_FIFO); // 使用先进先出调度策略

    // 创建线程1和线程2
    pthread_create(&tid1, &attr1, increment, NULL);
    pthread_create(&tid2, &attr2, decrement, NULL);

    // 等待线程1和线程2结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    // 销毁线程属性
    pthread_attr_destroy(&attr1);
    pthread_attr_destroy(&attr2);

    return 0;
}

在上面的示例中，我们创建了两个线程 `increment` 和 `decrement`，分别打印从0递增和从5递减的数字。我们使用 `pthread_attr_setschedparam` 函数来设置不同的时间片大小，并通过 `pthread_attr_setschedpolicy` 函数设置不同的调度策略。线程1使用了循环调度策略（SCHED_RR），时间片大小为10ms；线程2使用了先进先出调度策略（SCHED_FIFO），时间片大小为20ms。

请注意，设置时间片大小和调度策略可能需要在具有特权的状态下进行（例如，使用root用户）。另外，调度策略和时间片大小的实际效果也受到系统负载和其他因素的影响。以上示例仅为演示多线程使用不同时间片和调度策略的一种方式，结果可能因系统而异。

Linux下C语言实现多线程排序代码

以下是一个简单的Linux下C语言实现多线程排序的代码：

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

#define NUM_THREADS 4
#define ARRAY_SIZE 10000

int array[ARRAY_SIZE];

void* sort(void* arg) {
    int id = *(int*)arg;
    int start = id * (ARRAY_SIZE / NUM_THREADS);
    int end = (id + 1) * (ARRAY_SIZE / NUM_THREADS);

    // 使用快速排序对数组进行排序
    qsort(&array[start], end - start, sizeof(int), compare);

    pthread_exit(NULL);
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    pthread_t threads[NUM_THREADS];
    int thread_ids[NUM_THREADS];

    // 初始化数组
    for (int i = 0; i < ARRAY_SIZE; i++) {
        array[i] = rand();
    }

    // 创建线程
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i;
        pthread_create(&threads[i], NULL, sort, &thread_ids[i]);
    }

    // 等待线程结束
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    // 合并排序结果
    int sorted_array[ARRAY_SIZE];
    int indexes[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        indexes[i] = i * (ARRAY_SIZE / NUM_THREADS);
    }

    for (int i = 0; i < ARRAY_SIZE; i++) {
        int min_index = -1;
        for (int j = 0; j < NUM_THREADS; j++) {
            if (indexes[j] < (j + 1) * (ARRAY_SIZE / NUM_THREADS)) {
                if (min_index == -1 || array[indexes[j]] < array[indexes[min_index]]) {
                    min_index = j;
                }
            }
        }
        sorted_array[i] = array[indexes[min_index]];
        indexes[min_index]++;
    }

    // 打印排序结果
    for (int i = 0; i < ARRAY_SIZE; i++) {
        printf("%d ", sorted_array[i]);
    }
    printf("\n");

    return 0;
}

这个代码使用了4个线程对一个10000个整数的数组进行排序，实现了快速排序算法。每个线程排序数组的一个子集，然后合并排序结果。使用pthread库实现多线程功能，包括创建线程、等待线程结束等。