线程锁模拟交叉点

Question

I am trying to simulate an intersection using threads and mutex locks.

I have functions for going strait, turn left, turn right. Now, i have a function for approaching the intersection. This generates a random orientation and turn. Each thread shares the approaching intersection.

I have all the locks defined for all the cars in all directions.

Take the going strait function. It has a switch statement that just prints what car is doing what at the time. Now, i am just not sure what to lock in this function. If the car is in direction pointing north would i lock east and west and same with the car pointing south going north?

Here is my locks which just calls a function to lock or unlock

#define NUMCARS 30

#define lock_NW(CAR) lock(CAR, NW_mutex)
#define lock_NE(CAR) lock(CAR, NE_mutex)
#define lock_SW(CAR) lock(CAR, SW_mutex)
#define lock_SE(CAR) lock(CAR, SE_mutex)

#define unlock_NW(CAR) unlock(CAR, NW_mutex)
#define unlock_NE(CAR) unlock(CAR, NE_mutex)
#define unlock_SW(CAR) unlock(CAR, SW_mutex)
#define unlock_SE(CAR) unlock(CAR, SE_mutex)

here is main

int main(int argc, char **argv){
/* Initial variables*/
int index, tid;
unsigned int carids[NUMCARS];
pthread_t carthreads[NUMCARS];

/* Start up a thread for each car*/ 
for(index = 0; index <NUMCARS; index++){
carids[index] = index;
tid = pthread_create(&carthreads[index], NULL, approachintersection,  (void*)&carids[index]);
}

/* Wait for every car thread to finish */
for(index = 0; index <NUMCARS; index++){
pthread_join(carthreads[index], NULL);
}
printf("Done\n");
return 1;
}

here is the approaching intersection which calls the function going strait

static void * approachintersection(void* arg){
unsigned int * carnumberptr;
unsigned int carnumber;
orientation_t cardir = (orientation_t)random()%4;
unsigned long turn = random()%3;

carnumberptr = (unsigned int*) arg;
carnumber = (unsigned int) *carnumberptr;

if(turn==LEFT){
turnleft(cardir, carnumber);
} else if(turn==RIGHT){
turnright(cardir, carnumber);
} else {//straight
gostraight(cardir, carnumber);
}

return (void*)carnumberptr;
}

Now, here is the going strait function where i want to lock the appropriate directions.

 /*
  cardirection - The direction the car is pointing.  If it is pointing NORTH,
  it is starting from the South-Eastern corner of the intersection
  and "going straight" means it wants to move SOUTH to NORTH.

  valid options: NORTH, SOUTH, EAST, WEST

 carnumber -    The car identifier
*/


static void gostraight(orientation_t cardirection, unsigned int carnumber){

switch(cardirection){
case NORTH:
printf("Car %d, Moving South-North\n", carnumber);
break;
case SOUTH:
printf("Car %d, Moving North-South\n", carnumber);
break;
case EAST:
printf("Car %d, Moving West-East\n", carnumber);
break;
case WEST:
printf("Car %d, Moving East-West\n", carnumber);
break;
}
}

So, if the approaching car is pointing north from south the car would be the SE car and i would lock case east, west print function with lock_SE(CAR)? preventing the other threads from coming in and printing? so i would lock unlock the print statements?

Or would i lock the whole switch statement?

** EDIT: would this be the way to do it? **

static void turnleft(orientation_t cardirection, unsigned int carnumber){

int CAR;
CAR = carnumber;


  switch(cardirection){
  case NORTH:
  lock_SE(CAR)
  printf("Car %d, Moving South-West\n", carnumber);
  unlock_SE(CAR)
  break;
  case SOUTH:
  lock_NW(CAR)
  printf("Car %d, Moving North-East\n", carnumber);
  unlock_NW(CAR)
  break;
  case EAST:
  lock_SW(CAR)
  printf("Car %d, Moving West-North\n", carnumber);
  unlock_SW(CAR)
  break;
  case WEST:
  lock_NE(CAR)
  printf("Car %d, Moving East-South\n", carnumber);
  unlock_NE(CAR)
  break;
  }

}

Answer 1

This is not an easy problem. I'll try to show two solutions.

First the obvious one: One mutex for the entire intersection, in the beginning of turnleft, turnright, gostraight add lock(car, intersection_mutex); , just before the end of each function release said mutex. This will only let one car in through the intersection at a time. The upside of this is that it's easy to understand and will not result in dead locks. The downside is that a only one car can enter at a time but as we all know two cars travelling non-intersecting paths can enter without issues. Here's an example of go_straight() (the others follow the same approach):

static void gostraight(orientation_t cardirection, unsigned int carnumber){
    pthread_mutex_lock(&intersection_mutex);
    switch(cardirection){
        case NORTH:
            printf("Car %d, Moving South-North\n", carnumber);
            break;
        case SOUTH:
            printf("Car %d, Moving North-South\n", carnumber);
            break;
        case EAST:
            printf("Car %d, Moving West-East\n", carnumber);
            break;
        case WEST:
            printf("Car %d, Moving East-West\n", carnumber);
            break;
        }
    }
    pthread_mutex_unlock(&intersection_mutex);
}

To let more than one car in at a time we need a fine grained approach. The problem with a fine grained approach is that it's much harder to implement and get correct. Both go_straight and turn_left needs to lock two mutexes (you could argue that turn left needs three..). So if you can't acquire both mutexes you need to back off. Translating this into driving rules:

you must not enter the intersection before you can exit it. 

So, to go straight we must first acquire the mutex nearest to you, then the next one in your path to be able to exit. If we can't get both we must release the one we have locked. If we don't release it we will dead-lock.

To do this I'd add two helper functions:

static void lock_two(pthread_mutex_t *a, pthread_mutex_t *b) {
    while(1) { 
        pthread_mutex_lock(a);
        if(pthread_mutex_trylock(b) == 0) 
            break;
        else
        /* We must release the previously taken mutex so we don't dead lock the intersection */
            pthread_mutex_unlock(a);                            
        pthread_yield(); /* so we don't spin over lock/try-lock failed */
    }
}
static void unlock_two(pthread_mutex_t *a, pthread_mutex_t *b) {
    pthread_mutex_unlock(a);
    pthread_mutex_unlock(b);
}

Here's my version of go straight:

static void gostraight(orientation_t cardirection, unsigned int carnumber){  
    switch(cardirection){
        case NORTH:
            lock_two(&SE_mutex, &NE_mutex); 
            printf("Car %d, Moving South-North\n", carnumber);
            unlock_two(&SE_mutex, &NE_mutex); 
            break;
        case SOUTH:
            lock_two(&NW_mutex, &SW_mutex); 
            printf("Car %d, Moving North-South\n", carnumber);
            unlock_two(&NW_mutex, &SW_mutex); 
            break;
        case EAST:
            lock_two(&SW_mutex, &SE_mutex); 
            printf("Car %d, Moving West-East\n", carnumber);
            unlock_two(&SW_mutex, &SE_mutex); 
       break;
       case WEST:
            lock_two(&NE_mutex, &NW_mutex); 
            printf("Car %d, Moving East-West\n", carnumber);
            unlock_two(&NE_mutex, &NW_mutex); 
            break;
    }
}

turn_left would then need to follow the same approach.

Answer 2

Well something like this would work for the going straight function :-

static void gostraight(orientation_t cardirection, unsigned int carnumber){
  int CAR;
  cAR = carnumber;

  switch(cardirection){
    case NORTH:
      lock_SE(CAR);
      lock_NE(CAR);
      printf("Car %d, Moving South-North\n", carnumber);
      unlock_NE(CAR);
      unlock_SE(CAR);
      break;
    case SOUTH:
      lock_NW(CAR);
      lock_SW(CAR);
      printf("Car %d, Moving North-South\n", carnumber);
      unlock_SW(CAR);
      unlock_NW(CAR);
      break;
    case EAST:
      lock_SE(CAR);
      lock_SW(CAR);
      printf("Car %d, Moving West-East\n", carnumber);
      unlock_SE(CAR);
      unlock_SW(CAR);
      break;
    case WEST:
      lock_NE(CAR);
      lock_NW(CAR);
      printf("Car %d, Moving East-West\n", carnumber);
      unlock_NW(CAR);
      unlock_NE(CAR);
      break;
  }
}

For the left turn, (just giving one example) :-

switch(cardirection) {
  case NORTH:
    lock_SE(CAR);
    lock_NE(CAR);
    lock_NW(CAR);
    printf("Car %d, Moving South-West\n", carnumber);
    unlock_NW(CAR);
    unlock_NE(CAR);
    unlock_SE(CAR);
    break;
}

For right turn (again just one example) :-

switch(cardirection) {
  case EAST:
    lock_SW(CAR);
    printf("Car %d, Moving East-South\n", carnumber);
    unlock_SW(CAR);
    break;
}

Note that in order to avoid deadlocks, I am always locking them in the arbitrary order of SE, NE, NW, SW.

Why this works? eg, take a car that wants to go straight south and another that is headed north and turning left to west. Then if the left turning car comes first, it will lock SE, NE and NW in that order and the straight going car will not be able to get the lock on NW. However, a car going east and turning right to south will be able to get the lock on SW.

Hence, this scheme will work. It won't have a deadlock because each function obtains the locks in a given order. Hence there can never be cyclic chain of threads competing for corners. Basically, if a thread 1 is waiting for a thread 2 to release a lock, then that means thread 2 does not require any of the locks already obtained by thread 1. Hence there can be no deadlock.

Answer 3

I'm not quite sure I understand what you need to do, but I'll have a try at explaining my reasoning. I'll start at the design, since I guess that's where your problem lies.

You assume a plain intersection, two roads, no lights, no signs. Any car can arrive at the intersection from four different directions, north, south, east and west, and each car can take one of three different directions when passing the intersection. This way, you have 4 * 3 = 12 different road sections you'd have to consider, all different.

If a car crosses the intersection on a certain path at a certain moment, it blocks traffic at zero or more, theoretically up to 11, different sections (in practice, at least two sections remain free, so the limit is 9). These you have to block. BTW, it helps if you make a picture of the 12 different sections.

If you want to use mutexes, you'd need one for each section (not necessarily for a car). Assuming a right hand, right-before-left driving scenario, a car coming from the south intending to go straight would be blocking:

• a car coming from the east going straight;
• a car coming from the east going left;
• a car coming from the east going right;
• a car coming from the west going straight;
• a car coming from the west going left;
• a car coming from the north going left;

All other sections are free for other cars. You can create this list of blocks for every arrival/direction pair. [You'd have to specify how two left-turning cars from opposite directions shall pass each other, ie whether a car coming from north turning left will block a car coming from south turning left, or whether they can pass before one another]

Blocking so many mutexes (one for each section) on behalf of each car (read: thread) presents a problem: Deadlock. In order to solve that problem here, I'd suggest you create an additional, 'master' mutex for the whole intersection. When a car arrives,

1. it tries to block the master mutex; if unsuccessful, it blocks.
2. it then tries to block each of the section-mutexes it needs; if unsuccessful, release all successfully locked mutexes, unlock the master mutex, and wait, then try again starting from 1.
3. If it succeeded in blocking all needed section mutexes, unlock the master mutex, and pass the intersection (taking time).

After passing the intersection, the car

1. tries to block the master mutex; if unsuccessful, it blocks.
2. it unlocks all acquired section mutexes.
3. it unlocks the master mutex again.
4. continues its way in the new direction.

[Edited to clarify, and pthread mutexes allow trying to lock and backing off] The master mutex is always released very quickly, only used to see if a car can obtain all necessary section mutexes or not. Either way, the master mutex is released immediately aftre that.

Without a master mutex you can avoid deadlock only by using a strict order for obtaining the mutexes. This would make the intersection partial: If two cars arrive at the same time, one direction/turn combination will always win over another one. The master mutex avoids that.