b'\n_START_ARTICLE_\nAlgoritmo do banqueiro\n_START_SECTION_\nAlgoritmo\n_START_PARAGRAPH_\nO algoritmo do banqueiro \xc3\xa9 executado pelo sistema operacional quando um processo de computa\xc3\xa7\xc3\xa3o requisita recursos.._NEWLINE_O algoritmo impede o impasse, ao negar ou adiar o pedido se ele determinar que aceitar o pedido pode colocar o sistema em um estado inseguro (onde um impasse poderia ocorrer). Quando um novo processo entra em um sistema, ele deve declarar o n\xc3\xbamero m\xc3\xa1ximo de inst\xc3\xa2ncias de cada tipo de recurso que n\xc3\xa3o pode exceder o n\xc3\xbamero total de recursos no sistema.\n_START_SECTION_\nExemplo\n_START_PARAGRAPH_\nSupondo que o sistema distingue quatro tipos de recursos, (A, B, C e D), o seguinte \xc3\xa9 um exemplo de como esses recursos poderiam ser distribu\xc3\xaddos. Note que este exemplo mostra o sistema em um instante antes de um novo pedido de recursos chegar. Al\xc3\xa9m disso, os tipos e n\xc3\xbamero de recursos s\xc3\xa3o abstra\xc3\xaddos. Sistemas reais, por exemplo, lidariam com quantidades muito maiores de cada recurso._NEWLINE_Recursos do sistema dispon\xc3\xadveis s\xc3\xa3o:_NEWLINE_A B C D_NEWLINE_3 1 1 2_NEWLINE_Processos (recursos atualmente alocados):_NEWLINE_   A B C D_NEWLINE_P1 1 2 2 1_NEWLINE_P2 1 0 3 3_NEWLINE_P3 1 1 1 0_NEWLINE_Processos (m\xc3\xa1ximo de recursos):_NEWLINE_   A B C D_NEWLINE_P1 3 3 2 2_NEWLINE_P2 1 2 3 4_NEWLINE_P3 1 1 5 0\n_START_SECTION_\nEstados seguros e inseguros\n_START_PARAGRAPH_\nUm estado (como no exemplo acima) \xc3\xa9 considerada seguro se \xc3\xa9 poss\xc3\xadvel para todos os processos concluir sua execu\xc3\xa7\xc3\xa3o (terminar). Desde que o sistema n\xc3\xa3o pode saber quando o processo ser\xc3\xa1 encerrado, ou quantos recursos ele ter\xc3\xa1 solicitado at\xc3\xa9 ent\xc3\xa3o, o sistema assume que todos os processos acabar\xc3\xa3o por tentar adquirir o m\xc3\xa1ximo de seus recursos previstos e encerrar logo depois. Esta \xc3\xa9 uma suposi\xc3\xa7\xc3\xa3o razo\xc3\xa1vel na maioria dos casos uma vez que o sistema n\xc3\xa3o est\xc3\xa1 particularmente preocupado com o tempo que cada processo \xc3\xa9 executado (pelo menos n\xc3\xa3o numa perspectiva de preven\xc3\xa7\xc3\xa3o de deadlocks). Al\xc3\xa9m disso, se um processo termina sem adquirir o seu m\xc3\xa1ximo de recursos, isto s\xc3\xb3 torna mais f\xc3\xa1cil para o sistema._NEWLINE_Dada esta premissa, o algoritmo determina se um estado \xc3\xa9 seguro, tentando encontrar um conjunto hipot\xc3\xa9tico de pedidos pelos processos que permitiriam a cada, a aquisi\xc3\xa7\xc3\xa3o de seus recursos m\xc3\xa1ximos e depois o seu t\xc3\xa9rmino (retornando os seus recursos para o sistema). Qualquer estado onde tal conjunto n\xc3\xa3o existe \xc3\xa9 definido como um estado inseguro.\n_START_SECTION_\nPseudoc\xc3\xb3digo\n_START_PARAGRAPH_\nfunction algoritmo_do_banqueiro(conjunto de processos P, recursos atualmente dispon\xc3\xadveis A) {_NEWLINE_    while (P n\xc3\xa3o vazio) {_NEWLINE_        boolean achou = false_NEWLINE_        for each (processo p in P) {_NEWLINE_            C\xe2\x82\x9a = atual aloca\xc3\xa7\xc3\xa3o de recursos para o processo(p)_NEWLINE_            M\xe2\x82\x9a = requisito m\xc3\xa1ximo de recursos para o processo(p)_NEWLINE_            if (M\xe2\x82\x9a \xe2\x88\x92 C\xe2\x82\x9a \xe2\x89\xa4 A) {_NEWLINE_                // p pode obter tudo de que necessita._NEWLINE_                // Suponha que ele faz isso, termina, e libera o que ele j\xc3\xa1 tem._NEWLINE_                A = A + C\xe2\x82\x9a_NEWLINE_                remove_elemento_do_conjunto(p, P)_NEWLINE_                achou = true_NEWLINE_            }_NEWLINE_        }_NEWLINE_        if (not achou) {_NEWLINE_            return INSEGURO_NEWLINE_        }_NEWLINE_    }_NEWLINE_    return SEGURO_NEWLINE_}\n_START_SECTION_\nTrade-offs\n_START_PARAGRAPH_\nComo a maioria dos algoritmos, o algoritmo do banqueiro envolve alguns dilemas (trade-offs). Especificamente, ele precisa saber o quanto de cada recurso de um processo poderia ser requerido. Na maioria dos sistemas, esta informa\xc3\xa7\xc3\xa3o n\xc3\xa3o est\xc3\xa1 dispon\xc3\xadvel, fazendo com que o algoritmo do banqueiro seja in\xc3\xbatil. Al\xc3\xa9m disso, \xc3\xa9 irrealista supor que o n\xc3\xbamero de processos seja est\xc3\xa1tico. Na maioria dos sistemas o n\xc3\xbamero de processos varia dinamicamente. Al\xc3\xa9m disso, a exig\xc3\xaancia de que um processo acabar\xc3\xa1 por liberar todos os seus recursos (quando o processo termina) \xc3\xa9 suficiente para a corre\xc3\xa7\xc3\xa3o do algoritmo, por\xc3\xa9m n\xc3\xa3o \xc3\xa9 suficiente para um sistema pr\xc3\xa1tico. Esperar por horas (ou at\xc3\xa9 mesmo_NEWLINE_dias) que os recursos sejam liberados normalmente n\xc3\xa3o \xc3\xa9 aceit\xc3\xa1vel.'