这是一个模拟银行窗口排队叫号调度系统，参考了网上两篇文章，一篇java的和一篇linux c++的，然后我在windows下实现了它，开发工具是vs2008.在文章最后我会给出直接可编译可执行代码。

Java版参考：http://blog.csdn.net/zhangxiaoxiang/article/details/6294132
Linux c++版参考：http://blog.csdn.net/yanjiashang/article/details/6359652

模拟实现银行业务调度系统逻辑，具体需求如下：
• 银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
• 有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。
• 异步随机生成各种类型的客户，生成各类型用户的概率比例为：
VIP客户：普通客户：快速客户 = 1 ：6 ：3。
• 客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。
• 各类型客户在其对应窗口按顺序依次办理业务。
• 当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
• 随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
分析，注意一下几点：
1、 其实实现方法还是挺多的，可以用3个队列分别表示vip，fast和commer，也可以只用一个list，直接在里面找，我就只用了一个list。
2、 NumberMachine要设计为单例类。
3、 注意同步与互斥的问题，同时避免死锁。当表为空时，即每人来的的时候，线程应该在等待资源，而不是一直在循环。最后假设银行一天最多只能处理50个人最为终结条件。

代码关键的地方有加点注释，我觉得不需要解释还是可以看懂了，那就直接上代码吧，文章最后会把完整程序一并给出。同时，需要看到程序有什么不妥的地方请指出，互相探讨，共同进步。

Bank_queue.cpp

#include "stdafx.h"

#include <iostream>  
#include <process.h>

#include <stdio.h>  
#include <stdlib.h>  
#include <time.h>  
#include "numMachine.h"  
#include "serviceWin.h"  
#include "client.h"  
#include "constances.h"  
using namespace std;

HANDLE thread1[4];
HANDLE thread2;
HANDLE thread3;
map<int,HANDLE> thread_Map;
enum ID{
    THREAD1_0,THREAD1_1,THREAD1_2,THREAD1_3,THREAD2,THREAD3
};

Client::ClientType createClientType() {  
    int type;  
    type = rand() % 10 + 1;  
    if (type <= 6)  
        return Client::CLIENT_COMMON;  
    else if (type >= 7 && type <= 9)  
        return Client::CLIENT_FAST;  
    return Client::CLIENT_VIP;  
}  
int createTasktime() {  
    return rand() % MAX_SERVICE_TIME + 1;  
}  
void createClient() {  
    Client::ClientType clientType;  
    int taskTime;  
    for (int i = 0; i < MAX_CLIENT_NUM; ++i) {  
        clientType = createClientType();  
        taskTime = createTasktime();  
        std::cout << "Come in a client : clientType = " << clientType  
            << " taskTime = " << taskTime << std::endl;  
        NumMachine::getInstance()->pressMachine(clientType, taskTime);  
        Sleep(1);

    }  
}  
unsigned  __stdcall serviceWin(void *win) {  
    ServiceWin *serWin = static_cast<ServiceWin*> (win);    
    serWin->execute(); 
    TerminateThread(thread_Map[serWin->getCount()],0);
    return 0;
}  
bool createServiceWin(HANDLE thread1[],HANDLE &thread2,HANDLE &thread3) {    
    unsigned commonServiceWin[4];  
    unsigned fastServiceWin;  
    unsigned vipServiceWin;  

    char tmp[20]={0};  
    ServiceWin *win;  
    for (int i = 0; i < 4; ++i) {  
        sprintf(tmp, "CommonWin%d", i);  
        win = new CommonSerWin(tmp);  
        if (win == NULL) {  
            std::cout << "Create common service win error." << std::endl;  
            return -1;  
        }
        win->setCount(i);
        //_beginthreadex返回handle
        if ((thread1[i] = (HANDLE)_beginthreadex(NULL, 0,serviceWin, (void*) win,0,&commonServiceWin[i]) )== 0) {  
                std::cout << "Create common service thread error." << std::endl;  
                return false;  
        }
        thread_Map.insert(map<int,HANDLE>::value_type(i,thread1[i]));

    }  
    memset(tmp,0,sizeof(tmp));
    sprintf(tmp, "FastWin");  
    win = new FastSerWin(tmp);  
    if (win == NULL) {  
        std::cout << "Create fast service win error." << std::endl;  
        return false;  
    }  
    win->setCount(THREAD2);
    if ((thread2 = (HANDLE )_beginthreadex(NULL, 0,serviceWin, (void*) win,0,NULL/*&fastServiceWin*/)) == 0) {  
        std::cout << "Create fast service thread error." << std::endl;  
        return false;  
    }
    thread_Map.insert(map<int,HANDLE>::value_type(THREAD2,thread2));
    memset(tmp,0,sizeof(tmp));
    sprintf(tmp, "VipWin");  
    win = new VipSerWin(tmp);  
    if (win == NULL) {  
        std::cout << "Create vip service win error." << std::endl;  
        return false;  
    }  
    win->setCount(THREAD3);
    if ((thread3 = (HANDLE)_beginthreadex(NULL, 0,serviceWin, (void*) win,0,&vipServiceWin)) == 0) {  
        std::cout << "Create vip service thread error." << std::endl;  
        return false;  
    }  
    thread_Map.insert(map<int,HANDLE>::value_type(THREAD3,thread3));
    return true;  
}  
int _tmain(int argc, char *argv[]) {  
    std::cout << "/***start : please wait 5 seconds when progress suspend *****/" << std::endl;  


    srand((unsigned) time(0));  
    if (!createServiceWin(thread1,thread2,thread3)) {  
        std::cout << "Create service win error." << std::endl;  
        return -1;  
    }  
    createClient();  

    for(int i = 0; i<4; i++)
        WaitForSingleObject(thread1[i],INFINITE);
    WaitForSingleObject(thread2,INFINITE);
    WaitForSingleObject(thread3,INFINITE);
    delete NumMachine::getInstance();  
    for(int i = 0; i<4; i++)
        CloseHandle(thread1[i]);
    CloseHandle(thread2);
    CloseHandle(thread3);
}  

numberMachine.cpp

#include "StdAfx.h"
#include "numMachine.h"

NumMachine * NumMachine::numMachine = new NumMachine;  
NumMachine::NumMachine() :  
leaveClient(0), total(0), handledClient(0) {  
//  pthread_mutex_init(&clientListLock, NULL);  
    clientListLock=CreateMutex(NULL,false,NULL);
    clientPressLock=CreateMutex(NULL,false,NULL);
    m_CommerSem=CreateSemaphore(NULL, 0, 50, NULL);//当前个资源，最大允许个同时访问
    m_FastSem=CreateSemaphore(NULL, 0, 50, NULL);//当前个资源，最大允许个同时访问
    m_VipSem=CreateSemaphore(NULL, 0, 50, NULL);//当前个资源，最大允许个同时访问
    m_map.insert(map<Client::ClientType,HANDLE>::value_type(Client::CLIENT_COMMON,m_CommerSem));
    m_map.insert(map<Client::ClientType,HANDLE>::value_type(Client::CLIENT_FAST,m_FastSem));
    m_map.insert(map<Client::ClientType,HANDLE>::value_type(Client::CLIENT_VIP,m_VipSem));

}  
NumMachine::~NumMachine() {  
    std::cout << "/**********     end         ****************/" << std::endl;  
    std::cout << "The number of total client is " << total << std::endl;  
    std::cout << "The number of handled client is " << handledClient << std::endl;  
    std::cout << "The number of waiting client is " << clientList.size() << std::endl;  
    std::cout << "The number of client is " << leaveClient  
        << " ,because waiting time too long." << std::endl;  
    for_each(clientList.begin(), clientList.end(), DelClientList()); 
    CloseHandle(clientListLock);
}  
NumMachine * NumMachine::getInstance() {  
    return numMachine;  
}  
void NumMachine::pressMachine(Client::ClientType clientType, int taskTime) {  
    ++total;  
    if (clientList.size() < MAX_WAITING_CLIENT_NUM) {  
        Client * c = new Client(clientType, taskTime);  
        if (c == NULL) {  
            ReleaseMutex(clientPressLock);
            std::cout << "Can't create Client" << std::endl;  
            exit(-1);  
        }  
        clientList.push_back(c);  
        //semaphore
        ReleaseSemaphore(m_map[clientType],1,NULL);
    } else {  
        ++leaveClient;  
    }
}  
int NumMachine::getTotal(){
    return total;
}

Client * NumMachine::removeClient(Client::ClientType val) {  
    std::list<Client*>::iterator pos;  
    Client *tmp;  
    if (total == MAX_CLIENT_NUM)
    {
        DWORD rtn = WaitForSingleObject(m_map[val],1000);
        if (WAIT_TIMEOUT == rtn)
        {
#ifdef DEBUG
            std::cout<<"val:"<<val<<",rtn:WAIT_TIMEOUT"<<std::endl; 
#endif
            return NULL;
        }
        if (WAIT_ABANDONED == rtn)
        {
#ifdef DEBUG
            std::cout<<"val:"<<val<<",rtn:WAIT_ABANDONED"<<std::endl;
#endif
            return NULL;
        }
        if (WAIT_FAILED == rtn)
        {
#ifdef DEBUG
            std::cout<<"val:"<<val<<",rtn:WAIT_FAILED"<<std::endl;
#endif
            return NULL;
        }
    }else{
        DWORD rtn = WaitForSingleObject(m_map[val],3000);
        if (WAIT_TIMEOUT == rtn)
        {
#ifdef DEBUG
            std::cout<<" total < MAX_CLIENT_NUM val:"<<val<<",rtn:WAIT_TIMEOUT"<<std::endl;     
#endif
        }
        if (WAIT_ABANDONED == rtn)
        {
#ifdef DEBUG
            std::cout<<"total < MAX_CLIENT_NUM val:"<<val<<",rtn:WAIT_ABANDONED"<<std::endl;
#endif
        }
        if (WAIT_FAILED == rtn)
        {
#ifdef DEBUG
            std::cout<<"total < MAX_CLIENT_NUM val:"<<val<<",rtn:WAIT_FAILED"<<std::endl;
#endif
        }
    }
    WaitForSingleObject(clientListLock,INFINITE);
    pos = find_if(clientList.begin(), clientList.end(), FindClient(val));  
    if (pos != clientList.end()) {  

        ++handledClient;  
        tmp = *pos; 
        clientList.erase(pos); 
        ReleaseMutex(clientListLock);

        return tmp;  
    } else {   
        ReleaseMutex(clientListLock);   
        return NULL;  
    }  
}  
void DelClientList::operator ()(Client *item) {  
    std::cout << "Waiting client : clientType =" << item->getClientType()  
        << " taskTime = " << item->getServiceTime() << std::endl;  
    delete item;  
}  
FindClient::FindClient(Client::ClientType t) :  
clientType(t) {  
}  
bool FindClient::operator ()(Client * item) {  
    if (item->getClientType() == clientType)  
        return true;  
    else  
        return false;  
}  

serviceWin.cpp

#include "stdafx.h"
#include "serviceWin.h"  
ServiceWin::ServiceWin(std::string n) :  
winName(n) {  
}  
ServiceWin::~ServiceWin() {  
}  
std::string ServiceWin::getWinName() {  
    return winName;  
}  
CommonSerWin::CommonSerWin(std::string n) :  
ServiceWin(n) {  
}  
CommonSerWin::~CommonSerWin() {  
}  
void CommonSerWin::execute() {  
    Client * client = NULL;  
    while (1) {  
        client = NumMachine::getInstance()->removeClient(Client::CLIENT_COMMON);  
        if (client != NULL) {  
            std::cout << "A client be handled : clientType = " << client->getClientType()  
                << " taskTime = " << client->getServiceTime() << " "<< getWinName()<< std::endl;  
            Sleep(client->getServiceTime());  
            delete client;  
        }else{
            if (MAX_CLIENT_NUM == NumMachine::getInstance()->getTotal())
            {
                return;
            }
        }  
    }  
}  
FastSerWin::FastSerWin(std::string n) :  
ServiceWin(n) {  
}  
FastSerWin::~FastSerWin() {  
}  
void FastSerWin::execute() {  
    Client * client = NULL;  
    while (1) {  
        client = NumMachine::getInstance()->removeClient(Client::CLIENT_FAST);  
        if (client != NULL) {  
            std::cout << "A client be handled : clientType = " << client->getClientType()  
                << " taskTime = " << client->getServiceTime() << " "<< getWinName() << std::endl;  
            Sleep(client->getServiceTime());  
            delete client;  
        }else{
            if (MAX_CLIENT_NUM == NumMachine::getInstance()->getTotal())
            {
                return;
            }
        }    
    }  
}  
VipSerWin::VipSerWin(std::string n) :  
ServiceWin(n) {  
}  
VipSerWin::~VipSerWin() {  
}  
void VipSerWin::execute() {  
    Client * client = NULL;  
    while (1) {  
        client = NumMachine::getInstance()->removeClient(Client::CLIENT_VIP);  
        if (client != NULL) {  
            std::cout << "A client be handled : clientType = " << client->getClientType()  
                << " taskTime = " << client->getServiceTime() << " "<< getWinName() << std::endl;  
            Sleep(client->getServiceTime());  
            delete client;  
        }else{
            if (MAX_CLIENT_NUM == NumMachine::getInstance()->getTotal())
            {
                return;
            }
        }    
    }  
}  

执行结果:

完整程序下载地址:
http://download.csdn.net/detail/luomoshusheng/8927561