线程调度程序仿真：唤醒和休眠Pthread的正确方法

Question

I am trying to design my own thread scheduler using a First Come First Serve strategy, and I'm not sure whether the way I put threads to sleep and wake them up is the correct approach. I am using C++ and the Pthreads library.

My idea is this:

• Main thread instantiates a worker thread.
• Separate schedule() function gets called from a worker thread denoting that the calling thread should be scheduled. Passes in an arrival time , id , remaining time .
• Within schedule() , create my own Thread object which stores the arrival time , id , and remaining time attributes of a particular thread (these are attributes that I made up). The Thread object also has its own condition variable.
• Every time the schedule() function gets called, a Thread object will be created and added to the back of the queue.
• Once the Thread object has been added to the queue, the thread that called schedule() should wait on its corresponding condition variable.
• Then the condition variable of the Thread object at the front of the queue should be signaled, indicating that it should run. All other threads should wait on the condition variables in their respective Thread objects.

Example : 5 Thread objects exist in queue[0] , queue[1] , queue[2] , queue[3] , and queue[4] . The thread represented by queue[0] should be running, and the threads represented by queue[1] , queue[2] , queue[3] , and queue[4] should be waiting on their respective condition variables. Once queue[0] finishes executing, it will get removed from the queue, all the Thread objects will be moved forward, and the new queue[0] will be signaled to run. If I call schedule() from a new worker thread now, a new Thread object should be created and added at queue[4] . The calling thread should then wait on queue[4] .

To test out this design, I wrote an example. I omitted the arrival time , id , and remaining time fields because they are not important at this point. Here is the example code:

#include <iostream>
#include <string>
#include <vector>
#include <pthread.h>
using namespace std;

class Thread {
    public:
            pthread_cond_t conVar;
};

vector<Thread> queue;
pthread_mutex_t lock;

void schedule() {
    pthread_mutex_lock(&lock);
    cout << "Thread 1 locks the mutex\n";
    queue.push_back(first);
    pthread_cond_wait(&(queue.back()).conVar,&lock);
}

void *worker(void *arg) {

    Thread first;
    cout << "Thread 1 adding to queue. Going for the wait...\n";

    schedule();

    cout << "Got out of the wait. Let's do some work\n";

    for(int i = 0; i < 20; i++)
            cout << i << " ";

    cout << "\n";

    pthread_exit(NULL);
}

int main() {


    vector<Thread> queue;
    pthread_t a;

    pthread_create(&a,NULL,worker,NULL);
    cout << "Sleeping in the main thread for a bit....\n";
    sleep(1);

    cout << "Now let's signal the Thread object in the queue\n";

    int result = pthread_mutex_trylock(&lock);
    if(result != 0)
            sleep(3);
    pthread_cond_signal(&(queue.front()).conVar);
    pthread_mutex_unlock(&lock);
    pthread_join(a,NULL);


    return 0;

}

I have tried this example code several times, and the main thread always executes first and tries to signal the front of the queue. The worker thread never gets the queue in time to insert the Thread object, and I keep getting a segfault because the main thread tries to signal a condition variable that doesn't exist.

My question is this : Is this design a valid way to put threads to sleep and wake them up as part of a scheduling algorithm? Or will the main thread always execute first and try to signal an empty queue?

Answer 1

The 'main' thread is just a thread that happens to be created by the OS loader instead of by user code. It is not 'special' in any way.

One problem is that you are trying to synchronize threads with sleep calls. This will not end well.

If you want to try this, signal the other way first. Pass a condvar to the worker and wait on it in main. When the worker has inserted itself into the queue, it can signal the condvar so that main can continue.