线程操作，大概思路如下：

1. 创建4个线程，表示四个窗口，用semaphore来等待客户进入（WaitForSingleObject）.

2. 创建n个线程表示客户，每创建一个客户增加一个ReleaseSemaphore，以让窗口处理（记录相关信息，随机时间可以用srand获取），窗口要设定为while循环，可以多次处理，条件可以设置为处理多少个客户就可以退出.

3. 共用资源记得设置临界区CriticalSection.

#include<malloc.h>

#define N 10

int main(void)

{

int i,j,x,m,flag=1

char ch

m=N

char (*p)[10]=(char (*)[10])calloc(N,10*sizeof(char))

for(i=0i<10i++)

for(j=0j<10j++)

p[i][j]='\0'

printf("输入ID时不超过10位,第一位不能为'*'\n")

i=0

while(1)

{

while(i<m)

{

printf("请输入第%d名的ID:",i+1)

ch=getchar()

for(j=0j<10j++)

{

if(j==0&&ch=='*')

{

flag=0

break

}

if(ch=='\n')

break

p[i][j]=ch

ch=getchar()

}

if(flag==0)

break

i=i+1

}

if(flag==0)

break

m=m+N

p=(char (*)[10])realloc(p,m*10*sizeof(char))

for(x=ix<mx++)

for(j=0j<10j++)

p[x][j]='\0'

}

for(j=0j<ij++)

{

printf("第%d名:",j+1)

printf("%s\n",p[j])

}

free(p)

return 0

}

很明显 这个只要实现队列一切就简单了 其实c++有quene类 这里我们自己实现它

剩下的自己来写就好了 很简单的

首先一个链表的

using namespace std

//链表

typedef struct QDode

{

     int n

 struct QDode *next

}*pqdode,qdode

//队列

typedef struct MyQueue

{

pqdode front

pqdode rear

}*pmyqueue,myqueue

bool Init_queue(pmyqueue qu)//初始化队列

bool Is_empty(pmyqueue qu)//判断队列是否为空

void Put_queue(pmyqueue qu,int val)//入队

int  Out_queue(pmyqueue qu)//出队

int  Travel_queue(pmyqueue qu)//遍历队列

void Destory_queue(pmyqueue qu)//销毁队列

//主函数

int main()

{ 

    myqueue queue={NULL,NULL}

    Init_queue(&queue)//初始化

Put_queue(&queue,5)//入队

if (!Is_empty(&queue))

{

cout<<"队列不为空"<<endl

}

Put_queue(&queue,6)

    Put_queue(&queue,7)

Put_queue(&queue,8)

Put_queue(&queue,9)

    Travel_queue(&queue)//遍历

int val=Out_queue(&queue)

cout<<endl<<endl<<val<<endl<<endl

Travel_queue(&queue)//遍历

int vall=Out_queue(&queue)

cout<<endl<<endl<<vall<<endl<<endl

    Travel_queue(&queue)//遍历

Destory_queue(&queue)//销毁

    cout<<endl

return 0

}

bool Init_queue(pmyqueue qu)

{

 qu->front = new qdode

 if (qu->front==NULL)

 {

 cout<<"动态分配内存失败!"<<endl

 return false

 }

 else

 {

         qu->rear=qu->front

 qu->front->next=NULL

 return true

 }

}

void Destory_queue(pmyqueue qu)

{

 pqdode p=qu->front,q=NULL

 while (p)

 {

         q = p->next

         delete p

 p = q

 }

 p = NULL

}

void Put_queue(pmyqueue qu,int val)

{

 qu->rear->n = val

 pqdode q=qu->rear

 pqdode p = new qdode

 p->next = NULL

 qu->rear = p

     q->next = p

}

bool Is_empty(pmyqueue qu)

{

 if (qu->front!=qu->rear)

 {

 return false

 }

 else

 {

 return true

 }

}

int Travel_queue(pmyqueue qu)

{

    int count=0

if (Is_empty(qu))

{

cout<<"该队列为空！"<<endl

return 0

}

else

{

        pqdode p=qu->front,q=NULL

while (p!=qu->rear)

{

count++

cout<<p->n<<"    "

if (!(count%5))

{

cout<<endl

}

p = p->next

}

    return count

}

}

int Out_queue(pmyqueue qu)

{

if (Is_empty(qu))

{

cout<<"该队列为空！"<<endl

return -1

}

else

{

        int val=qu->front->n

pqdode p = qu->front->next

delete qu->front

qu->front = p

    return val

}

}

然后一个数组实现的

using namespace std

class  QUEUE       //队列类

{

private:         //私有成员

   int  *pBase

   int  front,rear

   int  count

public:         //公有成员

       bool Is_empty()//判断是否为空

   bool Is_full()//判断是否满

       void enter_queue(int n)//入队

       int  out_queue()//出队

   void travel_queue()//遍历队

   QUEUE (int number = 100)

   {

          front  =  rear  =  0

          pBase  =  new int[number+1]

  count  =  number  +  1

   }

       ~QUEUE()

   {

   delete [] pBase

   }

}

int main()

{

    QUEUE queue(5)

queue.enter_queue(1)

queue.enter_queue(2)

queue.enter_queue(3)

queue.enter_queue(4)

queue.enter_queue(5)

    queue.enter_queue(6)

queue.travel_queue()

queue.out_queue()

queue.travel_queue()

queue.out_queue()

queue.travel_queue()

queue.out_queue()

queue.travel_queue()

queue.out_queue()

queue.travel_queue()

queue.out_queue()

queue.travel_queue()

queue.out_queue()

if (queue.Is_full())

{

cout<<"wangbadan"<<endl

}

int n = queue.out_queue()

cout<<n<<endl

queue.travel_queue()

int n1 = queue.out_queue()

cout<<n1<<endl

queue.travel_queue()

return 0

}

bool QUEUE::Is_empty()//判断是否满

{

     if (front == rear)

     {

 return true

     }

 else

 {

 return false

 }

}

bool QUEUE::Is_full()//判断是否空

{

if ((rear + 1) % count == front)

{

return true

}

else

{

return false

}

}

void QUEUE::enter_queue(int n)//入队

{

 if (Is_full())

 {

 cout<<"队列已满！"<<endl

 }

 else

 {

 pBase[rear]=n

     rear = (rear + 1) % count

 }

 return

}

int QUEUE::out_queue()//出队

{

 int n = pBase[front]

     if (Is_empty())

     {

 cout<<"该队列已空！"<<endl

 return false

     }

 else

 {

 front = (front + 1) % count

 return n

 }

}

void QUEUE::travel_queue()//遍历

{

 int j=0

 for (int i=fronti % count != reari++)

 {

 j++

 cout<<pBase[i%count]<<"  "

 if (j==5)

 {

             cout<<endl

 j=0

 }

 }

 if (j)

 {

 cout<<endl

 }

 return

}