Как получить доступ к информации о потоке в программе

Вопрос 1: Я пытаюсь назвать каждый поток, поэтому его можно использовать во всей программе, но я получаю такие ошибки, как "запрос для члена" fid "в" плоскостях [t] ", который относится к классу типа" pthread_t ", не относящемуся к классу. ссылаясь на использование плоскостей [t].tid или использование плоскостей [t].startState. Я не уверен, как еще получить/сохранить эти значения для каждого отдельного потока.

Вопрос 2: как только у меня есть thread startState, как я могу отправить поток функции takeoff() (серия состояний переключателей и printfs).

Вопрос 3: Что нужно передать в функцию StartState? Я пытаюсь, чтобы каждый поток помнил свое начальное состояние, так что позже в коде я могу полет "приземлиться" или "взлететь".

Вот соответствующий код: Обновлено 10/06 в 22:37

#include <pthread.h>
#include <stdio.h>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <unistd.h>
#include <algorithm>
#include <time.h>
#include <ctime> 

#define NUM_THREADS 3       //3 flights

using std::queue;
using std::vector; 

pthread_mutex_t runway1lock;
pthread_mutex_t runway2lock;

bool run1occupied;
bool run2occupied;

struct flight_data{                 //each plane has these characteristics
        //void *FlightID;
    long fid;
        int startState;        // if start=1 ==> taking off    :::     if start=2 ==> landing
        int flyTime;            //fly == randomly generated time (order) of takeoff/land                
};

struct flight_data flightinfo[NUM_THREADS];

void *FlightID(void *flightid){
        struct flight_data *my_flights;
        my_flights = (struct flight_data*)flightid;
        int taskid;
        taskid = my_flights->fid;
 //       long fid;
  //      fid = (long)flightid;
//      printf("Flight #%1d\n", tid);
        pthread_exit(NULL);
}

void Start(struct flight_data my_flights){
        my_flights = (struct flight_data)my_flights;
        int startState;
    srand(time(0));
    my_flights.startState = rand() % 2+1;
        std::string startstring;
        if(my_flights.startState == 1){
                startstring = "Taking off";
        }
        if(my_flights.startState == 2){
                startstring = "Landing";
        }
    for(int i = 1; i<NUM_THREADS+1; i++){
            std::cout << "Start state for Flight # " << i << " is " << startstring << std::endl;
    }
}

void takeoff(struct flight_data my_flights){
    my_flights = (struct flight_data)my_flights;    
    for(int i = 1; i<NUM_THREADS+1; i++){
        int state = my_flights.startState;
        switch(state){  
            case 1:{        //G (GATE)
                std::cout << "Flight # " << flightinfo[i].fid << " is listed as waiting at the gate." << std::endl; 
                std::cout << "Flight # " << flightinfo[i].fid << " position in queue for runway: " << flightinfo[i].flyTime << std::endl; 
                sleep(3);
                state = 2;
                break;
            }   
            case 2: {       //Q (queue) -- sets order for use of runway
                queue<pthread_t> queue;
                vector<int> flightTimes;    
                int soonestFlightTime = 10;
                flightTimes.push_back(flightinfo[i].flyTime);           //put all flight times into a vector called flightTimes
                std::sort(flightTimes.begin(), flightTimes.end());      //sort the vector of flightTimes low to high
                std::reverse(flightTimes.begin(), flightTimes.end());       //flips vector -- high(front) to low(back)
                while(!flightTimes.empty()){
                    if (flightinfo[i].flyTime == flightTimes.back()){   //if a thread has the soonest flight time   
                        queue.push(i);      //then put the flight in the runway queue
                        flightTimes.pop_back();     //pop off the soonest flight time 
                    }
                }   
                while(!queue.empty()){
                    if(flightinfo[i].fid == queue.front()){
                        state = 3;
                        queue.pop();
                        sleep(3);
                    }   
                }
                break;
            }
            case 3: {       //CLR (clearance for runway)
                std::cout << "Flight # " << flightinfo[i].fid << " has clearance to move to the runway." << std::endl;  //will go in order of queue
                if(run1occupied){
                    sleep(3);
                }
            //  else if(collide){
            //      state = 7;
            //  }
                else{
                    state = 4;
                }
                break;      
            }
            case 4: {       //RTO (runway takeoff)
                pthread_mutex_lock(&runway1lock);
                run1occupied = true;
                std::cout << "Flight # " << flightinfo[i].fid << " is taking off. Runway occupied. Stand by." << std::endl;
                sleep(3);
                pthread_mutex_unlock(&runway1lock);
                run1occupied = false;
                state = 5;
                break;
            }
            case 5: {       //CZ (cruise)
                std::cout << "Flight # " << flightinfo[i].fid << " is reaching proper altitude and cruising toward destination." << std::endl; 
                sleep(3);
            //  if(!collide){
                    state = 6;
            //  }
            //  else{
            //      state = 7;  //collision!!!
            //  }
                break;
            }
            case 6: {       //RMV (remove from monitoring list)
                std::cout << "Flight # " << flightinfo[i].fid << " has been removed from the monitoring list." << std::endl;
                break; 
            }       
            case 7:{        //COLL (collision)
                std::cout << "Collision in the air. There were many casualties." << std::endl;
                break;
            }
        }
    }
}

void landing(struct flight_data my_flights){
    my_flights = (struct flight_data)my_flights;
    for (int i = 0; i<NUM_THREADS; i++){
        int state = my_flights.startState;
        switch(state){
            case 1:{        //ENTR (enter monitoring list)
                state = 2;
                break;
            }
            case 2:{        //Q (queue)
                //if not the first thing in the queue then state = 4;
                //otherwise state = 3;
            }
            case 3:{        //RWL (runway land)
                state = 5;
                break;
            }
            case 4:{        //HVR (hover)
                //if first in queue then state = 3;
                //otherwise stay here
                //if collision state = 7;
            }
            case 5:{        //CLR (clearance to move to gate)
                //if collision state = 7
                //otherwise state = 6;
            }
            case 6:{        //G (gate)

            }
            case 7:{        //COLL (collision)

            }
        }
    }
}

/*
bool collision(){
    bool collide;
    //random
    if(){
        collide = true;
    }
    else{
        collide = false;
    }
    return collide;
}*/

int main(int argc, char *argv[]){
        pthread_t flights[NUM_THREADS];         //pthread_t keeps a thread ID after the thread is created with pthread_create()
                                                //it like an index on a vector of threads
        int *taskids[NUM_THREADS];
        int rc;
        long t;
        for (t=1; t<=NUM_THREADS; t++){                                 //loop creates threads(flights)
                printf("In main: Creating flight %1d\n", t);
                flightinfo[t].fid= t;
                rc = pthread_create(&flights[t], NULL, FlightID, (void *)&flights[t]);
                if (rc){
                        printf("ERROR: return code from pthread_create() is %d\n", rc);
                        return (-1);
                }
                printf("Created flight %1d\n", t);
        //      Start(flightinfo[t]);
                flightinfo[t].startState = rand() % 2+1;
                std::cout << flightinfo[t].startState << std::endl;
                if((flightinfo[t].startState)==1){
                        std::cout << "Flight # " << flightinfo[t].fid << " is listed with start state as " << flightinfo[t].startState << std::endl;
                        takeoff(flightinfo[t]);
                        //go to takeoff function and go through switch case     
                }
                if((flightinfo[t].startState)==2){
                        std::cout << "Flight # " << flightinfo[t].fid << " is listed with start state as " << flightinfo[t].startState << std::endl;
                        landing(flightinfo[t]);
                        //go to landing function and go through switch case     
                }
        }
        pthread_exit(NULL);
}