Tag: so2 2122
repo: controlAviao
aviao:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo
#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex
#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes
typedef struct _MSG_AEROPORTO {
TCHAR szMessagem[MSGTEXT_SZ];
int pidMessagemControl; //aviao
int pidMessagemAviao; //areoporto
int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;
typedef struct _ControlData { //tipo de estrutura de dados de controlo
HANDLE hSemBouncer; //semáforo
//para o mutex
HANDLE hMapFile, hRWMutex;
Shared_MSG* shared; // ponteiro para memoria partilhada
HANDLE newmsg; //ponteiro para o evento
int continuar; // vairvel para terminar as threads
} CData;
//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
Shared_MSG msg; //estrutura local
while (pcd->continuar)
{
msg.pidMessagemAviao = GetCurrentProcessId();
if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0 || (pcd->shared->pidMessagemAviao == GetCurrentProcessId() && pcd->shared->comando == 2))
{
_tprintf(TEXT("\ndone.."));
break;
}
_tprintf(TEXT("\n[aviao: %d]Escreve mensagem (fim para sair)"), msg.pidMessagemAviao);
wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
//_tprintf(TEXT("%s\n"), msg.szMessagem);
msg.comando = 1;
WaitForSingleObject(pcd->hRWMutex, INFINITE);
CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
ReleaseMutex(pcd->hRWMutex);
//assinlar que há nova mensagem
SetEvent(pcd->newmsg);
//esperar que mensagem seja lida por outros processos
Sleep(MSG_DELAY);
//desativar evento
ResetEvent(pcd->newmsg);
}
pcd->continuar = 0;
_tprintf(TEXT("\nPrograma vai terminar"));
//para desbloquear a outra thread e sair de imediato
SetEvent(pcd->newmsg);
}
DWORD WINAPI recebe_msg(LPVOID p)
{
CData* pcd = (CData*)p;
Shared_MSG msg;
while (1)
{
WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
if (!pcd->continuar)
{
break;
}
WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
ReleaseMutex(pcd->hRWMutex);
if (msg.pidMessagemAviao == GetCurrentProcessId()) {
_tprintf(TEXT("\nProblemas com o nome do aeroporto"));
msg.comando = 1;
}
else
{
_tprintf(TEXT("\n.."));
//_tprintf(TEXT("\nRecebi: %s do %d"), msg.szMessagem, msg.pidMessagemControl);
}
Sleep(MSG_DELAY * 2);
}
//no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
ResetEvent(pcd->newmsg);
return 0;
}
BOOL comunicaAeroporto(BOOL valor)
{
HANDLE sem; // Handle do semáforo
CData cdata; //estrutura de dados de controlo
DWORD tid; //estrutura de dados de controlo
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
cdata.hSemBouncer = CreateSemaphore(
NULL, //atributo de segurança
MAXUSERS, //começa o programa logo com o max users
MAXUSERS, //limite de users
SEM_BOUNCER_NAME //nome do semaforo
);
if (cdata.hSemBouncer == NULL)
{
_tprintf(TEXT("\nerro a criar semaforo"));
return FALSE;
}
else
{
_tprintf(TEXT("Semáforo criado\n"));
}
cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
FALSE,
SEM_BOUNCER_NAME
);
if (cdata.hSemBouncer == NULL)
{
_tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("Semáforo aberto.\n"));
}
_tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
WaitForSingleObject(cdata.hSemBouncer, INFINITE);
//criar a zona de memória
cdata.hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
sizeof(Shared_MSG),
SHM_NAME
);
if (cdata.hMapFile == NULL)
{
_tprintf(TEXT("Problema em criar zona de memoria (%d),\n"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\ncriada zona de memoria."));
}
//criar a zona de memória - a vista
cdata.shared = (Shared_MSG*)MapViewOfFile(
cdata.hMapFile,
FILE_MAP_ALL_ACCESS,
0,
0, //vista sobre a memoria inteira
sizeof(Shared_MSG)
);
if (cdata.shared == NULL)
{
_tprintf(TEXT("Problema em criar a vista (%d),\n"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\ncriada a vista."));
}
//criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
cdata.hRWMutex = CreateMutex(
NULL,
FALSE,
MUTEX_NAME
);
if (cdata.hRWMutex == NULL)
{
_tprintf(TEXT("Problema em criar o mutex (%d),\n"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\nmutex criado."));
}
cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));
if (cdata.newmsg == NULL)
{
_tprintf(TEXT("Erro ao criar evento %s (%d).\n"), TEXT("Evento"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\nEvento lançado com sucesso"));
}
_tprintf(TEXT("Lançar a thread para ouvir o que se passa\n"));
cdata.continuar = 1;
sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
le_envia(&cdata);
_tprintf(TEXT("Este cliente vai fechar\n"));
WaitForSingleObject(sem, INFINITE);
_tprintf(TEXT("Thread ouvinte encerrada\n"));
ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);
UnmapViewOfFile(cdata.shared); //memoria partilhada
CloseHandle(cdata.hMapFile);
CloseHandle(cdata.newmsg);
CloseHandle(cdata.hSemBouncer);
valor = TRUE;
return valor;
}
int _tmain(int argc, TCHAR* argv[]) {
BOOL entra = FALSE;
while (entra == FALSE)
{
entra = comunicaAeroporto(FALSE);
}
_tprintf(TEXT("\ntou feliz... cara#######"));
return 0;
}
control:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo
#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex
#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes
typedef struct _MSG_AEROPORTO {
TCHAR szMessagem[MSGTEXT_SZ];
int pidMessagemControl; //aviao
int pidMessagemAviao; //areoporto
int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;
typedef struct _ControlData { //tipo de estrutura de dados de controlo
HANDLE hSemBouncer; //semáforo
//para o mutex
HANDLE hMapFile, hRWMutex;
Shared_MSG* shared; // ponteiro para memoria partilhada
HANDLE newmsg; //ponteiro para o evento
int continuar; // vairvel para terminar as threads
} CData;
//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
Shared_MSG msg; //estrutura local
while (pcd->continuar)
{
msg.pidMessagemControl = GetCurrentProcessId();
_tprintf(TEXT("\n[control: %d] Escreve mensagem (fim para sair)"), msg.pidMessagemControl);
wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
//_tprintf(TEXT("%s\n"), msg.szMessagem);
if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0)
{
break;
}
WaitForSingleObject(pcd->hRWMutex, INFINITE);
CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
ReleaseMutex(pcd->hRWMutex);
//assinlar que há nova mensagem
SetEvent(pcd->newmsg);
//esperar que mensagem seja lida por outros processos
Sleep(MSG_DELAY);
//desativar evento
ResetEvent(pcd->newmsg);
}
pcd->continuar = 0;
_tprintf(TEXT("\nPrograma vai terminar"));
//para desbloquear a outra thread e sair de imediato
SetEvent(pcd->newmsg);
}
DWORD WINAPI recebe_msg(LPVOID p)
{
CData* pcd = (CData*)p;
Shared_MSG msg;
TCHAR nome[MSGTEXT_SZ];
_tcscpy_s(nome, _countof(nome), _T("coimbra"));
while (1)
{
WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
if (!pcd->continuar)
{
break;
}
WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
ReleaseMutex(pcd->hRWMutex);
if (msg.comando == 1) {
_tprintf(TEXT("\nRecebi: %s do %d\n"), msg.szMessagem, msg.pidMessagemAviao);
if (wcscmp(msg.szMessagem, _T("coimbra")) == 0)
{
_tprintf(TEXT("\nSenhor aviao existe esse aeroporto.. volte sempre %d!"), msg.pidMessagemAviao);
pcd->shared->pidMessagemAviao = msg.pidMessagemAviao;
pcd->shared->comando = 2;
//Sleep(MSG_DELAY);
}
else
{
pcd->shared->comando = -1;
}
}
else
{
_tprintf(TEXT("\nAguardo por um pedido formal"));
pcd->shared->comando = -1;
}
Sleep(MSG_DELAY * 2);
pcd->shared->comando = -1;
}
//no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
ResetEvent(pcd->newmsg);
return 0;
}
BOOL comunicaAeroporto(BOOL valor)
{
HANDLE sem; // Handle do semáforo
CData cdata; //estrutura de dados de controlo
DWORD tid; //estrutura de dados de controlo
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
cdata.hSemBouncer = CreateSemaphore(
NULL, //atributo de segurança
MAXUSERS, //começa o programa logo com o max users
MAXUSERS, //limite de users
SEM_BOUNCER_NAME //nome do semaforo
);
if (cdata.hSemBouncer == NULL)
{
_tprintf(TEXT("\nerro a criar semaforo"));
return FALSE;
}
else
{
_tprintf(TEXT("\nSemáforo criado"));
}
cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
FALSE,
SEM_BOUNCER_NAME
);
if (cdata.hSemBouncer == NULL)
{
_tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\nSemáforo aberto."));
}
_tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
WaitForSingleObject(cdata.hSemBouncer, INFINITE);
//criar a zona de memória
cdata.hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
sizeof(Shared_MSG),
SHM_NAME
);
if (cdata.hMapFile == NULL)
{
_tprintf(TEXT("\nProblema em criar zona de memoria (%d),"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\ncriada zona de memoria."));
}
//criar a zona de memória - a vista
cdata.shared = (Shared_MSG*)MapViewOfFile(
cdata.hMapFile,
FILE_MAP_ALL_ACCESS,
0,
0, //vista sobre a memoria inteira
sizeof(Shared_MSG)
);
if (cdata.shared == NULL)
{
_tprintf(TEXT("\nProblema em criar a vista (%d),"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\ncriada a vista."));
}
//criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
cdata.hRWMutex = CreateMutex(
NULL,
FALSE,
MUTEX_NAME
);
if (cdata.hRWMutex == NULL)
{
_tprintf(TEXT("\nProblema em criar o mutex (%d),"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\nmutex criado."));
}
cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));
if (cdata.newmsg == NULL)
{
_tprintf(TEXT("\nErro ao criar evento %s (%d)."), TEXT("Evento"), GetLastError());
return FALSE;
}
else
{
_tprintf(TEXT("\nEvento lançado com sucesso"));
}
_tprintf(TEXT("\nLançar a thread para ouvir o que se passa"));
cdata.continuar = 1;
sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
le_envia(&cdata);
_tprintf(TEXT("\nEste cliente vai fechar"));
WaitForSingleObject(sem, INFINITE);
_tprintf(TEXT("\nThread ouvinte encerrada"));
ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);
UnmapViewOfFile(cdata.shared); //memoria partilhada
CloseHandle(cdata.hMapFile);
CloseHandle(cdata.newmsg);
CloseHandle(cdata.hSemBouncer);
valor = TRUE;
return valor;
}
int _tmain(int argc, TCHAR* argv[]) {
BOOL entra = FALSE;
while (entra == FALSE)
{
entra = comunicaAeroporto(FALSE);
}
}
repo: messageWINAPI
#include <windows.h>
#include <tchar.h>
/* ===================================================== */
/* Programa base (esqueleto) para aplicações Windows */
/* ===================================================== */
// Cria uma janela de nome "Janela Principal" e pinta fundo de branco
// Modelo para programas Windows:
// Composto por 2 funções:
// WinMain() = Ponto de entrada dos programas windows
// 1) Define, cria e mostra a janela
// 2) Loop de recepção de mensagens provenientes do Windows
// TrataEventos()= Processamentos da janela (pode ter outro nome)
// 1) É chamada pelo Windows (callback)
// 2) Executa código em função da mensagem recebida
LRESULT CALLBACK TrataEventos(HWND, UINT, WPARAM, LPARAM);
// Nome da classe da janela (para programas de uma só janela, normalmente este nome é
// igual ao do próprio programa) "szprogName" é usado mais abaixo na definição das
// propriedades do objecto janela
TCHAR szProgName[] = TEXT("Base");
// ============================================================================
// FUNÇÃO DE INÍCIO DO PROGRAMA: WinMain()
// ============================================================================
// Em Windows, o programa começa sempre a sua execução na função WinMain()que desempenha
// o papel da função main() do C em modo consola WINAPI indica o "tipo da função" (WINAPI
// para todas as declaradas nos headers do Windows e CALLBACK para as funções de
// processamento da janela)
// Parâmetros:
// hInst: Gerado pelo Windows, é o handle (número) da instância deste programa
// hPrevInst: Gerado pelo Windows, é sempre NULL para o NT (era usado no Windows 3.1)
// lpCmdLine: Gerado pelo Windows, é um ponteiro para uma string terminada por 0
// destinada a conter parâmetros para o programa
// nCmdShow: Parâmetro que especifica o modo de exibição da janela (usado em
// ShowWindow()
typedef struct {
int valor;
TCHAR nome[80];
}DATA;
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow) {
HWND hWnd; // hWnd é o handler da janela, gerado mais abaixo por CreateWindow()
MSG lpMsg; // MSG é uma estrutura definida no Windows para as mensagens
WNDCLASSEX wcApp; // WNDCLASSEX é uma estrutura cujos membros servem para
// definir as características da classe da janela
DATA data = {10, _T("pedro")};
// ============================================================================
// 1. Definição das características da janela "wcApp"
// (Valores dos elementos da estrutura "wcApp" do tipo WNDCLASSEX)
// ============================================================================
wcApp.cbSize = sizeof(WNDCLASSEX); // Tamanho da estrutura WNDCLASSEX
wcApp.hInstance = hInst; // Instância da janela actualmente exibida
// ("hInst" é parâmetro de WinMain e vem
// inicializada daí)
wcApp.lpszClassName = szProgName; // Nome da janela (neste caso = nome do programa)
wcApp.lpfnWndProc = TrataEventos; // Endereço da função de processamento da janela
// ("TrataEventos" foi declarada no início e
// encontra-se mais abaixo)
wcApp.style = CS_HREDRAW | CS_VREDRAW; // Estilo da janela: Fazer o redraw se for
// modificada horizontal ou verticalmente
wcApp.hIcon = LoadIcon(NULL, IDI_APPLICATION); // "hIcon" = handler do ícon normal
// "NULL" = Icon definido no Windows
// "IDI_AP..." Ícone "aplicação"
wcApp.hIconSm = LoadIcon(NULL, IDI_INFORMATION); // "hIconSm" = handler do ícon pequeno
// "NULL" = Icon definido no Windows
// "IDI_INF..." Ícon de informação
wcApp.hCursor = LoadCursor(NULL, IDC_ARROW); // "hCursor" = handler do cursor (rato)
// "NULL" = Forma definida no Windows
// "IDC_ARROW" Aspecto "seta"
wcApp.lpszMenuName = NULL; // Classe do menu que a janela pode ter
// (NULL = não tem menu)
wcApp.cbClsExtra = 0; // Livre, para uso particular
wcApp.cbWndExtra = sizeof(DATA*); // Livre, para uso particular
wcApp.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
// "hbrBackground" = handler para "brush" de pintura do fundo da janela. Devolvido por
// "GetStockObject".Neste caso o fundo será branco
// ============================================================================
// 2. Registar a classe "wcApp" no Windows
// ============================================================================
if (!RegisterClassEx(&wcApp))
return(0);
// ============================================================================
// 3. Criar a janela
// ============================================================================
hWnd = CreateWindow(
szProgName, // Nome da janela (programa) definido acima
TEXT("Exemplo de Janela Principal em C"),// Texto que figura na barra do título
WS_OVERLAPPEDWINDOW, // Estilo da janela (WS_OVERLAPPED= normal)
CW_USEDEFAULT, // Posição x pixels (default=à direita da última)
CW_USEDEFAULT, // Posição y pixels (default=abaixo da última)
CW_USEDEFAULT, // Largura da janela (em pixels)
CW_USEDEFAULT, // Altura da janela (em pixels)
(HWND)HWND_DESKTOP, // handle da janela pai (se se criar uma a partir de
// outra) ou HWND_DESKTOP se a janela for a primeira,
// criada a partir do "desktop"
(HMENU)NULL, // handle do menu da janela (se tiver menu)
(HINSTANCE)hInst, // handle da instância do programa actual ("hInst" é
// passado num dos parâmetros de WinMain()
0); // Não há parâmetros adicionais para a janela
// ============================================================================
// 4. Mostrar a janela
// ============================================================================
SetWindowLongPtr(hWnd, 0, (LONG_PTR)&data);
ShowWindow(hWnd, nCmdShow); // "hWnd"= handler da janela, devolvido por
// "CreateWindow"; "nCmdShow"= modo de exibição (p.e.
// normal/modal); é passado como parâmetro de WinMain()
UpdateWindow(hWnd); // Refrescar a janela (Windows envia à janela uma
// mensagem para pintar, mostrar dados, (refrescar)…
// ============================================================================
// 5. Loop de Mensagens
// ============================================================================
// O Windows envia mensagens às janelas (programas). Estas mensagens ficam numa fila de
// espera até que GetMessage(...) possa ler "a mensagem seguinte"
// Parâmetros de "getMessage":
// 1)"&lpMsg"=Endereço de uma estrutura do tipo MSG ("MSG lpMsg" ja foi declarada no
// início de WinMain()):
// HWND hwnd handler da janela a que se destina a mensagem
// UINT message Identificador da mensagem
// WPARAM wParam Parâmetro, p.e. código da tecla premida
// LPARAM lParam Parâmetro, p.e. se ALT também estava premida
// DWORD time Hora a que a mensagem foi enviada pelo Windows
// POINT pt Localização do mouse (x, y)
// 2)handle da window para a qual se pretendem receber mensagens (=NULL se se pretendem
// receber as mensagens para todas as
// janelas pertencentes à thread actual)
// 3)Código limite inferior das mensagens que se pretendem receber
// 4)Código limite superior das mensagens que se pretendem receber
// NOTA: GetMessage() devolve 0 quando for recebida a mensagem de fecho da janela,
// terminando então o loop de recepção de mensagens, e o programa
while (GetMessage(&lpMsg, NULL, 0, 0)) {
TranslateMessage(&lpMsg); // Pré-processamento da mensagem (p.e. obter código
// ASCII da tecla premida)
DispatchMessage(&lpMsg); // Enviar a mensagem traduzida de volta ao Windows, que
// aguarda até que a possa reenviar à função de
// tratamento da janela, CALLBACK TrataEventos (abaixo)
}
// ============================================================================
// 6. Fim do programa
// ============================================================================
return((int)lpMsg.wParam); // Retorna sempre o parâmetro wParam da estrutura lpMsg
}
// ============================================================================
// FUNÇÃO DE PROCESSAMENTO DA JANELA
// Esta função pode ter um nome qualquer: Apenas é necesário que na inicialização da
// estrutura "wcApp", feita no início de // WinMain(), se identifique essa função. Neste
// caso "wcApp.lpfnWndProc = WndProc"
//
// WndProc recebe as mensagens enviadas pelo Windows (depois de lidas e pré-processadas
// no loop "while" da função WinMain()
// Parâmetros:
// hWnd O handler da janela, obtido no CreateWindow()
// messg Ponteiro para a estrutura mensagem (ver estrutura em 5. Loop...
// wParam O parâmetro wParam da estrutura messg (a mensagem)
// lParam O parâmetro lParam desta mesma estrutura
//
// NOTA:Estes parâmetros estão aqui acessíveis o que simplifica o acesso aos seus valores
//
// A função EndProc é sempre do tipo "switch..." com "cases" que descriminam a mensagem
// recebida e a tratar.
// Estas mensagens são identificadas por constantes (p.e.
// WM_DESTROY, WM_CHAR, WM_KEYDOWN, WM_PAINT...) definidas em windows.h
// ============================================================================
LRESULT CALLBACK TrataEventos(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam) {
DATA* pData=(DATA*)GetWindowLongPtr(hWnd, 0);
switch (messg) {
case WM_CHAR:
if (wParam == 'a') {
MessageBox(hWnd, pData->nome, TEXT("informa"), MB_OK);
}
break;
case WM_DESTROY: // Destruir a janela e terminar o programa
// "PostQuitMessage(Exit Status)"
PostQuitMessage(0);
break;
default:
// Neste exemplo, para qualquer outra mensagem (p.e. "minimizar","maximizar","restaurar")
// não é efectuado nenhum processamento, apenas se segue o "default" do Windows
return(DefWindowProc(hWnd, messg, wParam, lParam));
break; // break tecnicamente desnecessário por causa do return
}
return(0);
}
repo: namedPipes (variosLeitores OverLappedIO) outra versão
escritor:
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
#define N 3
// estrutura do named pipe
typedef struct {
HANDLE hPipe; // handle do pipe
OVERLAPPED overlap;
BOOL activo; //representa se a instancia do named pipe esta ou nao ativa, se ja tem um cliente ou nao
} PipeDados;
typedef struct {
PipeDados hPipes[N];
HANDLE hEvents[N];
HANDLE hMutex;
int terminar;
}ThreadDados;
//envia mensagem para todos os leitores que estão disponiveis
DWORD WINAPI ThreadMensagens(LPVOID param) {
ThreadDados* dados = (ThreadDados*)param;
TCHAR buf[256];
DWORD n;
int i;
BOOL ret;
do {
_tprintf(TEXT("[ESCRITOR] Frase: "));
_fgetts(buf, 256, stdin);
buf[_tcslen(buf) - 1] = '\0';
for (i = 0; i < N; i++) {
// este named pipe está ativo? se sim vou escrever nele
if (dados->hPipes[i].activo == TRUE) {
if (!WriteFile(dados->hPipes[i].hPipe, buf, (DWORD)_tcslen(buf) * sizeof(TCHAR), &n, NULL)) {
_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
}
WaitForSingleObject(dados->hMutex, INFINITE);
ret=ReadFile(dados->hPipes[i].hPipe, buf, sizeof(TCHAR), &n, NULL);
ReleaseMutex(dados->hMutex);
//termina corretamente a string
buf[n / sizeof(TCHAR)] = '\0';
_tprintf(TEXT("[ESCRITOR] Recebi %d bytes [%s]... \n"), n, buf);
}
//libertamos o mutex
}
_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);
} while (_tcscmp(buf, TEXT("fim")));
dados->terminar = 1;
//vou assinalar todos os eventos para que nao fique bloqueado na main
for (i = 0; i < N; i++)
SetEvent(dados->hEvents[i]);
return 0;
}
int _tmain(int argc, LPTSTR argv[]) {
HANDLE hPipe, hThread, hEventTemp;
ThreadDados dados;
int i, numClientes = 0;
DWORD offset, nBytes;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
#endif
dados.terminar = 0;
dados.hMutex = CreateMutex(NULL, FALSE, NULL); //Criação do mutex
if (dados.hMutex == NULL) {
_tprintf(TEXT("[Erro] ao criar mutex!\n"));
return -1;
}
for (i = 0; i < N; i++) {
// aqui passamos a constante FILE_FLAG_OVERLAPPED para o named pipe aceitar comunicações assincronas
hPipe = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
N,
256 * sizeof(TCHAR),
256 * sizeof(TCHAR),
1000,
NULL);
if (hPipe == INVALID_HANDLE_VALUE) {
_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
exit(-1);
}
// criar evento que vai ser associado à esturtura overlaped
// os eventos aqui tem de ter sempre reset manual e nao automático porque temos de delegar essas responsabilidades ao sistema operativo
hEventTemp = CreateEvent(NULL, TRUE, FALSE, NULL);
if (hEventTemp == NULL) {
_tprintf(TEXT("[ERRO] ao criar evento\n"));
return -1;
}
dados.hPipes[i].hPipe = hPipe;
dados.hPipes[i].activo = FALSE;
//temos de garantir que a estrutura overlap está limpa
ZeroMemory(&dados.hPipes[i].overlap, sizeof(dados.hPipes[i].overlap));
//preenchemos agora o evento
dados.hPipes[i].overlap.hEvent = hEventTemp;
dados.hEvents[i] = hEventTemp;
_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor... (ConnectNamedPipe)\n"));
// aqui passamos um ponteiro para a estrutura overlap
ConnectNamedPipe(hPipe, &dados.hPipes[i].overlap);
}
//criacao da thread
hThread = CreateThread(NULL, 0, ThreadMensagens, &dados, 0, NULL);
if (hThread == NULL) {
_tprintf(TEXT("[Erro] ao criar thread!\n"));
return -1;
}
while (!dados.terminar && numClientes < N) {
//permite estar bloqueado , à espera que 1 evento do array de enventos seja assinalado
offset = WaitForMultipleObjects(N, dados.hEvents, FALSE, INFINITE);
i = offset - WAIT_OBJECT_0; // devolve o indice da instancia do named pipe que está ativa, aqui sabemos em que indice o cliente se ligou
// se é um indice válido ...
if (i >= 0 && i < N) {
_tprintf(TEXT("[ESCRITOR] Leitor %d chegou\n"), i);
if (GetOverlappedResult(dados.hPipes[i].hPipe, &dados.hPipes[i].overlap, &nBytes, FALSE)) {
// se entrarmos aqui significa que a funcao correu tudo bem
// fazemos reset do evento porque queremos que o WaitForMultipleObject desbloqueio com base noutro evento e nao neste
ResetEvent(dados.hEvents[i]);
//vamos esperar que o mutex esteja livre
WaitForSingleObject(dados.hMutex, INFINITE);
dados.hPipes[i].activo = TRUE; // dizemos que esta instancia do named pipe está ativa
ReleaseMutex(dados.hMutex);
numClientes++;
}
}
}
//esperar que a thread termine
WaitForSingleObject(hThread, INFINITE);
//desligamos todos os clientes que se ligaram
for (int i = 0; i < N; i++) {
_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));
//desliga todas as instancias de named pipes
if (!DisconnectNamedPipe(dados.hPipes[i].hPipe)) {
_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
exit(-1);
}
}
exit(0);
}
leitor:
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>
// ...
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
int _tmain(int argc, LPTSTR argv[]) {
TCHAR buf[256];
HANDLE hPipe;
int i = 0;
BOOL ret;
DWORD n;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
#endif
_tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"), PIPE_NAME);
//espera que exista um named pipe para ler do mesmo
//bloqueia aqui
if (!WaitNamedPipe(PIPE_NAME, NMPWAIT_WAIT_FOREVER)) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
//ligamo-nos ao named pipe que ja existe nesta altura
//1º nome do named pipe, 2ºpermissoes (têm de ser iguais ao CreateNamedPipe do servidor), 3ºshared mode 0 aqui,
//4º security atributes, 5ºflags de criação OPEN_EXISTING, 6º o default é FILE_ATTRIBUTE_NORMAL e o 7º é o template é NULL
hPipe = CreateFile(PIPE_NAME, PIPE_ACCESS_DUPLEX, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hPipe == NULL) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Liguei-me...\n"));
while (1) {
//le as mensagens enviadas pelo servidor
ret = ReadFile(hPipe, buf, sizeof(TCHAR), &n, NULL);
//termina corretamente a string
buf[n /sizeof(TCHAR)] = '\0';
if (!ret || !n) {
_tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
break;
}
_tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
for (int i = 0; i < (int)n; i++) {
if (!WriteFile(hPipe, buf, (DWORD)_tcslen(buf) * sizeof(TCHAR), &n, NULL)) {
_tprintf(TEXT("[ERRO] escrever no pipe\n"));
}
else {
_tprintf(TEXT("[LEITOR] enviei %d butes ao escritor\n"), n);
}
}
}
CloseHandle(hPipe);
Sleep(200);
return 0;
}
repo: namedPipes (variosLeitores OverLappedIO)
escritor:
//escritor || servidor
//comunicação assincrona (overlapped)
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
#define N 10 //numero de clientes
typedef struct {
HANDLE hPipe;
OVERLAPPED overlapped; //estrutura overlapped
BOOL activo; //se já tem um cliente (pipe) activo ou nao
}PipeDados;
typedef struct {
PipeDados hPipeDados[N];
HANDLE hEvents[N];
int numeroLeitores; //saber em tempo real a quantidade de leitores
HANDLE hMutex;//sincronização: acesso sincronizado ao array
int terminar; //controlar o fim da thread
}ThreadDados;
//thread auxiliar, para enviar para um conjunto de handles mensagens
DWORD WINAPI TheadMensagens(LPVOID param) {
DWORD n;
TCHAR buf[256];
ThreadDados* dados = (ThreadDados*)param;
int i;
do {
_tprintf(TEXT("[ESCRITOR] Frase: "));
_fgetts(buf, 256, stdin);
buf[_tcslen(buf) - 1] = '\0';
WaitForSingleObject(dados->hMutex, INFINITE);
//região critica este ciclo do for
for (i = 0; i < dados->numeroLeitores; i++) {
//overlapped
if(dados->hPipeDados[i].activo){
if (!WriteFile(
dados->hPipeDados[i].hPipe,
buf, //a string
(DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
&n, //qt de informação que foi escrita
NULL
)) {
_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
exit(-1);
}
_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);
}
}
ReleaseMutex(dados->hMutex);
} while (_tcscmp(buf, TEXT("fim")));
dados->terminar = 1;
for(i=0; i<dados->numeroLeitores; i++)
{
SetEvent(dados->hEvents[i]);
}
return 0;
}
int _tmain(int argc, LPTSTR argv[]) {
HANDLE hPipe;
TCHAR buf[256]; //ou 256 * sizeof(TCHAR)
ThreadDados dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
dados.numeroLeitores = 0;
dados.terminar = 0;
dados.hMutex = CreateMutex(
NULL,
FALSE,
NULL
);
if (dados.hMutex == NULL) {
_tprintf(TEXT("[ERRO] CreateMutex! (CreateMutex)"));
exit(-1);
}
HANDLE hThreadMain;
hThreadMain = CreateThread(NULL, 0, TheadMensagens, &dados, 0, NULL);
if (hThreadMain == NULL) {
_tprintf(TEXT("[ERRO] CreateThread! (CreateThread)"));
exit(-1);
}
while (dados.terminar == 0) {
_tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);
hPipe = CreateNamedPipe(
PIPE_NAME, //nome
PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
N, //numero maximo de instancias
sizeof(buf), // tamnho do buffer de entrada
sizeof(buf), // tamnho do buffer de saida
1000, // default timeout, tempo de espera de um cliente
NULL //atributos de segurança
);
if (hPipe == INVALID_HANDLE_VALUE) {
_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
exit(-1);
}
_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));
if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
hPipe, //namepiped
NULL // overlaped
)) {
//devolve 0 se correr mal
_tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
exit(-1);
}
//novos clientes, e reigão critica
WaitForSingleObject(dados.hMutex, INFINITE);
dados.hPipeDados[dados.numeroLeitores].hPipe = hPipe;
//dados.hPipeDados[dados.numeroLeitores].overlapped;
dados.numeroLeitores++;
ReleaseMutex(dados.hMutex);
}
//esperar que a thread termine
WaitForSingleObject(hThreadMain, INFINITE);
for (int i = 0; i < dados.numeroLeitores; i++) {
_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));
if (!DisconnectNamedPipe(dados.hEvents[i])) {
_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
exit(-1);
}
}
// Sleep(2000);
// CloseHandle(hPipe);
return 0;
}
leitor:
//leitor || cliente
//comunicação assincrona (overlapped)
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
int _tmain(int argc, LPTSTR argv[]) {
TCHAR buf[256];
HANDLE hPipe;
int i = 0;
BOOL ret;
DWORD n;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
_tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
PIPE_NAME);
if (!WaitNamedPipe(
PIPE_NAME, //string do nome do namedPipe
NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
)) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
hPipe = CreateFile(
PIPE_NAME, //nome do namedPipe
GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
0, //shared mode
NULL, // security
OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
FILE_ATTRIBUTE_NORMAL, //flags
NULL // template nao usamos
);
if (hPipe == NULL) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Liguei-me...\n"));
while (1) {
ret = ReadFile( //cliente é só de leitura
hPipe, // handle do pipe
buf, //ponteiro onde escreve a informação lida
sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
&n, //ponteiro, a quantidade de bytes que foram escrito
NULL //overlaped, nao interessa
);
buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes
if (!ret || !n) {
_tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
break;
}
_tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
}
CloseHandle(hPipe);
Sleep(200);
return 0;
}
Comunicação assincrona (overlapped)
_operações que normamente bloqueiam até completarem (read, write) podem ser completadas em background pelo SO
_isto consegue-se passando um ponteiro não nulo para uma estrutura do tipo OVERLAPPED
_se na estrutura for passado um handle para um evento, esse evento é assinalado quando a operação for completada pelo SO
processo, faz:
pedido de operação overlapped (não bloqueante)
e operação feita em background pelo SO, faz:
evento (opcional)
a estrutura do tipo overlapped deve ser inicializada a zero
a estrutura pode levar o handle de evento, depois dele ser criado
OVERLAPPED overlap;
ZeroMemory(&overlap, sizeof(overlap));
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); //criar evento
overlap.hEvent = hEvent;
ConnectNamedPipe(hPipe, &overlap);
É possivel determinar o resultado de uma operação assincrona com GetOverlappedResult
BOOL GetOverlappedResult(
HANDLE hFile, //ponteiro para pipe, ficheiro,
LPOVERLAPPED lpOverLapped, // ponteiro para estrutura do tipo OVERLAPPED
LPWORD lpNumberOfBytesTransferred, // variavel para receber n de bytes
BOOl bWait //TRUE = espera que operação termine
);
repo: namedPipes (variosLeitores)
escritor:
//escritor || servidor
//(thread secundária para partilhar por todos os leitores em simultaneos)
//(mais do que um leitor ao mesmo tempo)
//(o acesso à informação de exclusão mutua)
//array com handles dos named pipes
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
#define N 10 //numero de clientes
typedef struct {
HANDLE hPipes[N];
int numeroLeitores; //saber em tempo real a quantidade de leitores
HANDLE hMutex;//sincronização: acesso sincronizado ao array
int terminar; //controlar o fim da thread
}ThreadDados;
//thread auxiliar, para enviar para um conjunto de handles mensagens
DWORD WINAPI TheadMensagens(LPVOID param) {
DWORD n;
TCHAR buf[256];
ThreadDados* dados = (ThreadDados*)param;
int i;
do {
_tprintf(TEXT("[ESCRITOR] Frase: "));
_fgetts(buf, 256, stdin);
buf[_tcslen(buf) - 1] = '\0';
WaitForSingleObject(dados->hMutex, INFINITE);
//região critica este ciclo do for
for (i = 0; i < dados->numeroLeitores; i++) {
if (!WriteFile(
dados->hPipes[i],
buf, //a string
(DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
&n, //qt de informação que foi escrita
NULL
)) {
_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
exit(-1);
}
_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);
}
ReleaseMutex(dados->hMutex);
} while (_tcscmp(buf, TEXT("fim")));
dados->terminar = 1;
//extra e depois do dados->terminar = 1;
//simular a entrada de um novo cliente para desbloquear o ConnectNamedPipe no _main
CreateFile(PIPE_NAME, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
return 0;
}
int _tmain(int argc, LPTSTR argv[]) {
HANDLE hPipe;
TCHAR buf[256]; //ou 256 * sizeof(TCHAR)
ThreadDados dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
dados.numeroLeitores = 0;
dados.terminar = 0;
dados.hMutex = CreateMutex(
NULL,
FALSE,
NULL
);
if (dados.hMutex == NULL) {
_tprintf(TEXT("[ERRO] CreateMutex! (CreateMutex)"));
exit(-1);
}
HANDLE hThreadMain;
hThreadMain = CreateThread(NULL, 0, TheadMensagens, &dados, 0, NULL);
if (hThreadMain == NULL) {
_tprintf(TEXT("[ERRO] CreateThread! (CreateThread)"));
exit(-1);
}
while (dados.terminar == 0) {
_tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);
hPipe = CreateNamedPipe(
PIPE_NAME, //nome
PIPE_ACCESS_OUTBOUND, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
N, //numero maximo de instancias
sizeof(buf), // tamnho do buffer de entrada
sizeof(buf), // tamnho do buffer de saida
1000, // default timeout, tempo de espera de um cliente
NULL //atributos de segurança
);
if (hPipe == INVALID_HANDLE_VALUE) {
_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
exit(-1);
}
_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));
//mas o fim nao funciona:
//1ª solução correta para desbloquear isto
//2ª solução simular que surge um cliente novo para desbloquear este ConnectNamedPipe quando é escrito fim
if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
hPipe, //namepiped
NULL // overlaped
)) {
//devolve 0 se correr mal
_tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
exit(-1);
}
//novos clientes, e reigão critica
WaitForSingleObject(dados.hMutex, INFINITE);
dados.hPipes[dados.numeroLeitores] = hPipe;
dados.numeroLeitores++;
ReleaseMutex(dados.hMutex);
}
//esperar que a thread termine
WaitForSingleObject(hThreadMain, INFINITE);
for (int i = 0; i < dados.numeroLeitores; i++) {
_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));
if (!DisconnectNamedPipe(dados.hPipes[i])) {
_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
exit(-1);
}
}
// Sleep(2000);
// CloseHandle(hPipe);
return 0;
}
leitor:
//leitor || cliente
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
int _tmain(int argc, LPTSTR argv[]) {
TCHAR buf[256];
HANDLE hPipe;
int i = 0;
BOOL ret;
DWORD n;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
_tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
PIPE_NAME);
if (!WaitNamedPipe(
PIPE_NAME, //string do nome do namedPipe
NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
)) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
hPipe = CreateFile(
PIPE_NAME, //nome do namedPipe
GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
0, //shared mode
NULL, // security
OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
FILE_ATTRIBUTE_NORMAL, //flags
NULL // template nao usamos
);
if (hPipe == NULL) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Liguei-me...\n"));
while (1) {
ret = ReadFile( //cliente é só de leitura
hPipe, // handle do pipe
buf, //ponteiro onde escreve a informação lida
sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
&n, //ponteiro, a quantidade de bytes que foram escrito
NULL //overlaped, nao interessa
);
buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes
if (!ret || !n) {
_tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
break;
}
_tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
}
CloseHandle(hPipe);
Sleep(200);
return 0;
}
repo: namedPipes
escritor:
//escritor || servidor
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
int _tmain(int argc, LPTSTR argv[]) {
DWORD n;
HANDLE hPipe;
TCHAR buf[256];
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
_tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);
hPipe = CreateNamedPipe(
PIPE_NAME, //nome
PIPE_ACCESS_OUTBOUND, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
1, //numero maximo de instancias
sizeof(buf), // tamnho do buffer de entrada
sizeof(buf), // tamnho do buffer de saida
1000, // default timeout, tempo de espera de um cliente
NULL //atributos de segurança
);
if (hPipe == INVALID_HANDLE_VALUE) {
_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
exit(-1);
}
while (1) {
_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));
if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
hPipe, //namepiped
NULL // overlaped
)) {
//devolve 0 se correr mal
_tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
exit(-1);
}
do {
_tprintf(TEXT("[ESCRITOR] Frase: "));
_fgetts(buf, 256, stdin);
buf[_tcslen(buf) - 1] = '\0';
if (!WriteFile(
hPipe,
buf, //a string
(DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
&n, //qt de informação que foi escrita
NULL
)) {
_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
exit(-1);
}
_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor... (WriteFile)\n"), n);
} while (_tcscmp(buf, TEXT("fim")));
_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));
if (!DisconnectNamedPipe(hPipe)) {
_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
exit(-1);
}
}
Sleep(2000);
CloseHandle(hPipe);
return 0;
}
leitor:
//leitor || cliente
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
int _tmain(int argc, LPTSTR argv[]) {
TCHAR buf[256];
HANDLE hPipe;
int i = 0;
BOOL ret;
DWORD n;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
_tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
PIPE_NAME);
if (!WaitNamedPipe(
PIPE_NAME, //string do nome do namedPipe
NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
)) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
hPipe = CreateFile(
PIPE_NAME, //nome do namedPipe
GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
0, //shared mode
NULL, // security
OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
FILE_ATTRIBUTE_NORMAL, //flags
NULL // template nao usamos
);
if (hPipe == NULL) {
_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
exit(-1);
}
_tprintf(TEXT("[LEITOR] Liguei-me...\n"));
while (1) {
ret = ReadFile( //cliente é só de leitura
hPipe, // handle do pipe
buf, //ponteiro onde escreve a informação lida
sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
&n, //ponteiro, a quantidade de bytes que foram escrito
NULL //overlaped, nao interessa
);
buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes
if (!ret || !n) {
_tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
break;
}
_tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
}
CloseHandle(hPipe);
Sleep(200);
return 0;
}
repo: graficoMenus
#include <windows.h>
#include <windowsx.h>
#include <tchar.h>
#include "resource.h"
#define NUM_CLIENTES 3
#define LIST_SIZE 8
TCHAR* LIST_ITENS[] = {
TEXT("10€"),
TEXT("20€"),
TEXT("40€"),
TEXT("60€"),
TEXT("80€"),
TEXT("100€"),
TEXT("150€"),
TEXT("200€")
};
LRESULT CALLBACK TrataEventos(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK TrataEventosLogin(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK TrataEventosLevantar(HWND, UINT, WPARAM, LPARAM);
TCHAR szProgName[] = TEXT("Ficha8");
typedef struct {
unsigned int ID;
TCHAR username[16];
TCHAR password[16];
unsigned int saldo;
} cliente;
typedef struct {
unsigned int tipo; // 1 = depósito, 2 = levantamento
unsigned int quantia;
unsigned int ID;
} operacao;
typedef struct {
cliente clientes[NUM_CLIENTES];
operacao historico[200];
unsigned int numOperacoes;
} dados;
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
HWND hWnd;
MSG lpMsg;
WNDCLASSEX wcApp;
HANDLE hAccel;
dados dadosPartilhados;
wcApp.cbSize = sizeof(WNDCLASSEX);
wcApp.hInstance = hInst;
wcApp.lpszClassName = szProgName;
wcApp.lpfnWndProc = TrataEventos;
wcApp.style = CS_HREDRAW | CS_VREDRAW;
wcApp.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
wcApp.hIconSm = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
wcApp.hCursor = LoadCursor(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
wcApp.lpszMenuName = MAKEINTRESOURCE(IDR_MENU_PRINCIPAL);
wcApp.cbClsExtra = sizeof(dados);
wcApp.cbWndExtra = 0;
wcApp.hbrBackground = CreateSolidBrush(RGB(220, 220, 220));
if (!RegisterClassEx(&wcApp))
return(0);
hWnd = CreateWindow(
szProgName,
TEXT("SO2 - Ficha 8"),
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
300,
150,
(HWND)HWND_DESKTOP,
(HMENU)NULL,
(HINSTANCE)hInst,
0);
dadosPartilhados.numOperacoes = 5; // Apenas para testar...
LONG_PTR x = SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)&dadosPartilhados);
ShowWindow(hWnd, nCmdShow);
hAccel = LoadAccelerators(NULL, MAKEINTRESOURCE(IDR_ACCELERATOR));
while (GetMessage(&lpMsg, NULL, 0, 0))
{
if (!TranslateAccelerator(hWnd, hAccel, &lpMsg))
{
TranslateMessage(&lpMsg);
DispatchMessage(&lpMsg);
}
}
return((int)lpMsg.wParam);
}
LRESULT CALLBACK TrataEventos(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
TCHAR str1[512], str2[512];
dados* dadosPartilhados;
dadosPartilhados = (dados*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
switch (messg)
{
case WM_CREATE:
EnableMenuItem(GetMenu(hWnd), ID_CONSULTA, MF_DISABLED | MF_GRAYED);
EnableMenuItem(GetMenu(hWnd), ID_LEVANTAMENTO, MF_DISABLED | MF_GRAYED);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case ID_LOGIN:
DialogBox(NULL, MAKEINTRESOURCE(IDD_DIALOG_LOGIN), hWnd, TrataEventosLogin);
EnableMenuItem(GetMenu(hWnd), ID_CONSULTA, MF_ENABLED);
EnableMenuItem(GetMenu(hWnd), ID_LEVANTAMENTO, MF_ENABLED);
break;
case ID_CONSULTA:
case ID_ACCELERATOR_CONSULTA:
LoadString(NULL, IDS_STR_CONSULTA, str1, 512);
_stprintf_s(str2, 512, TEXT("%s (%d)"), str1, dadosPartilhados->numOperacoes);
MessageBox(hWnd, str2, TEXT("String Table"), MB_OK | MB_ICONINFORMATION);
break;
case ID_ACCELERATOR_LEVANTAMENTO:
case ID_LEVANTAMENTO:
DialogBox(NULL, MAKEINTRESOURCE(IDD_DIALOG_LEVANTAMENTO), NULL, TrataEventosLevantar);
break;
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, messg, wParam, lParam);
break;
}
return(0);
}
LRESULT CALLBACK TrataEventosLogin(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
TCHAR username[16];
switch (messg)
{
case WM_COMMAND:
if (LOWORD(wParam) == IDOK)
{
GetDlgItemText(hWnd, IDC_EDIT_LOGIN, username, 16);
MessageBox(hWnd, username, TEXT("Username"), MB_OK | MB_ICONINFORMATION);
}
else if (LOWORD(wParam) == IDCANCEL)
{
EndDialog(hWnd, 0);
return TRUE;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
return TRUE;
}
return FALSE;
}
LRESULT CALLBACK TrataEventosLevantar(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
int i;
switch (messg)
{
case WM_INITDIALOG:
HWND hwndList = GetDlgItem(hWnd, IDC_LIST_MONTANTES);
SendMessage(hwndList, LB_RESETCONTENT, 0, 0);
for (i = 0; i < LIST_SIZE; i++)
SendMessage(hwndList, LB_ADDSTRING, 0, (LPARAM)LIST_ITENS[i]);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_LIST_MONTANTES)
{
switch (HIWORD(wParam))
{
case LBN_DBLCLK:
HWND hwndList = GetDlgItem(hWnd, IDC_LIST_MONTANTES);
i = (int)SendMessage(hwndList, LB_GETCURSEL, 0, 0);
MessageBox(hWnd, LIST_ITENS[i], TEXT("ListBox"), MB_OK | MB_ICONINFORMATION);
break;
}
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
return TRUE;
}
return FALSE;
}
e no resource.h
#define IDI_ICON_APP 101 #define IDR_MENU_PRINCIPAL 102 #define IDR_ACCELERATOR 107 #define IDD_DIALOG1 108 #define IDC_LOGIN 1001 #define IDC_PASSWORD 1002 #define ID_CANCEL 1003 #define IDC_LIST_MONTANTES 1004 #define IDC_EDIT1 1006 #define IDS_STR_CONSULTA 1006 #define ID_OPERA40001 40001 #define ID_OPERA40002 40002 #define ID_LOGIN 40003 #define IDD_DIALOG_LOGIN 40003 #define ID_CONSULTA 40004 #define ID_LEVANTAMENTO 40005 #define IDD_DIALOG_LEVANTAMENTO 40005 #define ID_ACCELERATOR_CONSULTA 40006 #define ID_ACCELERATOR_LEVANTAMENTO 40007 // Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 110 #define _APS_NEXT_COMMAND_VALUE 40009 #define _APS_NEXT_CONTROL_VALUE 1007 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif
repo: bufferCircular II
produtor:
//produtor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random
#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular
typedef struct {
int id;
int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular
typedef struct {
int numeroProdutores;
int numeroConsumidores;
int proximaPosicaoEscrita; //controlar
int proximaPosicaoLeitura; //controlar
CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada
typedef struct {
BufferCircular* memoriaPartilhada;
HANDLE hSemaforoControlaEscrita;
HANDLE hSemaforoControloLeitura;
HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
int controloDaThread; //flag, 1 sair, 0 caso contrário
int idProdutor;
}DadosThreads;
//lidar com o random
int numero_aleatorio(int min, int max) {
return rand() % (max - min + 1) + min; //valor entre min e max
}
//a trhead produtor
DWORD WINAPI ThreadEscritaProdutor(LPVOID param) {
DadosThreads* dados = (DadosThreads*)param;
CelulaBufferCircular celBC; //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
int contadorItensProduzidos = 0;
while (dados->controloDaThread == 0) {
celBC.id = dados->idProdutor;
//produzir o item
celBC.val = numero_aleatorio(10,99);
//escrever no buffer circular,
WaitForSingleObject(
dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que temos uma posicção de escrita
WaitForSingleObject(
dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que somos nos a escrever
//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
CopyMemory(
&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
&celBC,
sizeof(CelulaBufferCircular)
);
//a proxima posicao de escrita é incrementada
dados->memoriaPartilhada->proximaPosicaoEscrita++;
//cheguei ao limite volto à posicao 0
if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
}
//libertar o mutex
ReleaseMutex(dados->hMutexControloExclusaoMutua);
//libtertar o semaforo de leitura
//se ocupamos uma posição de escrita libertamos uma posição de leitura
//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1
contadorItensProduzidos++;
_tprintf(TEXT("\nProdutor %d produziu valor %d "), dados->idProdutor, celBC.val);
Sleep(numero_aleatorio(2, 4)*1000);
}
_tprintf(TEXT("\nProdutor %d produziu %d itens"), dados->idProdutor, contadorItensProduzidos);
return 0;
}
int _tmain(int argc, LPSTR argv[]) {
HANDLE hFileMap;
//mapeamento da memoria partilhada
DadosThreads dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
//lidar com o random
srand((unsigned int)time(NULL));
//os semaforos
dados.hSemaforoControlaEscrita = CreateSemaphore(
NULL,
TAM_BUFFER_CIRUCLAR,
TAM_BUFFER_CIRUCLAR,
TEXT("SO2_MEMORIA_ESCRITA")
);
if (dados.hSemaforoControlaEscrita == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
return 1;
}
dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
0, //quantidade de posições iniciais, não existe nada para ser lido
TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
TEXT("SO2_MEMORIA_LEITURA")
);
if (dados.hSemaforoControloLeitura == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
return 1;
}
//exclusao mutua para os produtores
dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_PRODUTOR"));
if (dados.hMutexControloExclusaoMutua == NULL) {
_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
return 1;
}
hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
int primeiroProcesso = FALSE;
//se existir é aberto
//se nao existe é nulo
if (hFileMap == NULL) {
//existe um problem é porque se calahar não existe
//criar a memoria partilhada
primeiroProcesso = TRUE;
hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
NULL,
PAGE_READWRITE, //nivel de protecão: lieura e escrita);
0, //dimensões da memoria partilhada: mais significativa
sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
);
if (hFileMap == NULL) {
_tprintf(TEXT("\nerro no CreateFileMapping"));
return 1;
}
}
dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
hFileMap,
FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
0, //offsets: onde é mapeada
0, //0 para mapear até ao final
0 //0 para mapear até ao final
);
if (dados.memoriaPartilhada == NULL) {
_tprintf(TEXT("\nerro no MapViewOfFile"));
return 1;
}
//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
if (primeiroProcesso == TRUE) {
dados.memoriaPartilhada->numeroConsumidores = 0;
dados.memoriaPartilhada->numeroProdutores = 0;
dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//criar a thread
dados.controloDaThread = 0;
//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
//ir à memoria partilhada
dados.memoriaPartilhada->numeroProdutores++;
dados.idProdutor = dados.memoriaPartilhada->numeroProdutores;
//liberta ro mutex
ReleaseMutex(dados.hMutexControloExclusaoMutua);
HANDLE hThread;
TCHAR comando[100];
hThread = CreateThread(NULL, 0, ThreadEscritaProdutor, &dados, 0, NULL);
if (hThread != NULL) {
_tprintf(TEXT("escreve qualquer coisa para sair"));
_getts_s(comando, 100);
dados.controloDaThread = 1;
WaitForSingleObject(hThread, INFINITE);
}
UnmapViewOfFile(dados.memoriaPartilhada);
//CloseHandle();
return 0;
}
consumidor:
//consumidor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random
#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular
typedef struct {
int id;
int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular
typedef struct {
int numeroProdutores;
int numeroConsumidores;
int proximaPosicaoEscrita; //controlar
int proximaPosicaoLeitura; //controlar
CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada
typedef struct {
BufferCircular* memoriaPartilhada;
HANDLE hSemaforoControlaEscrita;
HANDLE hSemaforoControloLeitura;
HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
int controloDaThread; //flag, 1 sair, 0 caso contrário
int idConsumidor;
}DadosThreads;
//a thread consumidor
DWORD WINAPI ThreadLeituraConsumidor(LPVOID param) {
DadosThreads* dados = (DadosThreads*)param;
CelulaBufferCircular celBC; //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
int contadorItensProduzidos = 0;
int soma = 0;
while (dados->controloDaThread == 0) {
//ler no buffer circular,
WaitForSingleObject(
dados->hSemaforoControloLeitura, //existe uma posição para ler
INFINITE
);
//temos a garantia que temos uma posicção de escrita
WaitForSingleObject(
dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que somos nos a ler
//os dois estão desbloqueados e vamos ser o unico consumdior que vai ler
CopyMemory(
&celBC, //copiar
&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoLeitura], //destino
sizeof(CelulaBufferCircular)
);
//a proxima posicao de escrita é incrementada
dados->memoriaPartilhada->proximaPosicaoLeitura++;
//cheguei ao limite volto à posicao 0
if (dados->memoriaPartilhada->proximaPosicaoLeitura == TAM_BUFFER_CIRUCLAR) {
dados->memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//libertar o mutex quando terminamos a leitura
ReleaseMutex(dados->hMutexControloExclusaoMutua);
//libtertar o semaforo de escrita
//se ocupamos uma posição de leitura libertamos uma posição de escrita
//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
ReleaseSemaphore(dados->hSemaforoControlaEscrita, 1, NULL); //apenas uma posição, 1
contadorItensProduzidos++;
soma = soma + celBC.val;
_tprintf(TEXT("\nConsumidor %d consumiu valor %d "), dados->idConsumidor, celBC.val);
//Sleep(numero_aleatorio(2, 4) * 1000);
}
_tprintf(TEXT("\nConsumidor %d consumiu %d acumulado"), dados->idConsumidor, soma);
return 0;
}
//a thread consumidor
DWORD WINAPI ThreadEscritaConsumidor(LPVOID param) {
DadosThreads* dados = (DadosThreads*)param;
CelulaBufferCircular celBC; //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
int contadorItensProduzidos = 0;
while (dados->controloDaThread == 0) {
celBC.id = dados->idConsumidor;
//produzir o item
celBC.val = numero_aleatorio(10, 99);
//escrever no buffer circular,
WaitForSingleObject(
dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que temos uma posicção de escrita
WaitForSingleObject(
dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que somos nos a escrever
//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
CopyMemory(
&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
&celBC,
sizeof(CelulaBufferCircular)
);
//a proxima posicao de escrita é incrementada
dados->memoriaPartilhada->proximaPosicaoEscrita++;
//cheguei ao limite volto à posicao 0
if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
}
//libertar o mutex
ReleaseMutex(dados->hMutexControloExclusaoMutua);
//libtertar o semaforo de leitura
//se ocupamos uma posição de escrita libertamos uma posição de leitura
//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1
contadorItensProduzidos++;
_tprintf(TEXT("\Consumdior %d produziu valor %d "), dados->idConsumidor, celBC.val);
Sleep(numero_aleatorio(2, 4) * 1000);
}
_tprintf(TEXT("\Consumdior %d produziu %d itens"), dados->idConsumidor, contadorItensProduzidos);
return 0;
}
int _tmain(int argc, LPSTR argv[]) {
HANDLE hFileMap;
//mapeamento da memoria partilhada
DadosThreads dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
//lidar com o random
srand((unsigned int)time(NULL));
//os semaforos
dados.hSemaforoControlaEscrita = CreateSemaphore(
NULL,
TAM_BUFFER_CIRUCLAR,
TAM_BUFFER_CIRUCLAR,
TEXT("SO2_MEMORIA_ESCRITA")
);
if (dados.hSemaforoControlaEscrita == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
return 1;
}
dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
0, //quantidade de posições iniciais, não existe nada para ser lido
TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
TEXT("SO2_MEMORIA_LEITURA")
);
if (dados.hSemaforoControloLeitura == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
return 1;
}
//exclusao mutua para os produtores
dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_CONSUMIDOR"));
if (dados.hMutexControloExclusaoMutua == NULL) {
_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
return 1;
}
hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
int primeiroProcesso = FALSE;
//se existir é aberto
//se nao existe é nulo
if (hFileMap == NULL) {
//existe um problem é porque se calahar não existe
//criar a memoria partilhada
primeiroProcesso = TRUE;
hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
NULL,
PAGE_READWRITE, //nivel de protecão: lieura e escrita);
0, //dimensões da memoria partilhada: mais significativa
sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
);
if (hFileMap == NULL) {
_tprintf(TEXT("\nerro no CreateFileMapping"));
return 1;
}
}
dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
hFileMap,
FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
0, //offsets: onde é mapeada
0, //0 para mapear até ao final
0 //0 para mapear até ao final
);
if (dados.memoriaPartilhada == NULL) {
_tprintf(TEXT("\nerro no MapViewOfFile"));
return 1;
}
//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
if (primeiroProcesso == TRUE) {
dados.memoriaPartilhada->numeroConsumidores = 0;
dados.memoriaPartilhada->numeroProdutores = 0;
dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//criar a thread
dados.controloDaThread = 0;
//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
//ir à memoria partilhada
dados.memoriaPartilhada->numeroConsumidores++;
dados.idConsumidor = dados.memoriaPartilhada->numeroConsumidores;
//libertar o mutex
ReleaseMutex(dados.hMutexControloExclusaoMutua);
HANDLE hThreadArray[2];
TCHAR comando[100];
hThreadArray[0] = CreateThread(NULL, 0, ThreadLeituraConsumidor, &dados, 0, NULL);
hThreadArray[1] = CreateThread(NULL, 0, ThreadEscritaConsumidor, &dados, 0, NULL);
if (hThreadArray[0] == NULL || hThreadArray[1] == NULL)
{
_tprintf(TEXT("nada de threads"));
ExitProcess(3);
}
WaitForMultipleObjects(2, hThreadArray, TRUE, INFINITE);
UnmapViewOfFile(dados.memoriaPartilhada);
//CloseHandle();
return 0;
}
repo: bufferCircular
consumidor
//consumidor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random
#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular
typedef struct {
int id;
int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular
typedef struct {
int numeroProdutores;
int numeroConsumidores;
int proximaPosicaoEscrita; //controlar
int proximaPosicaoLeitura; //controlar
CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada
typedef struct {
BufferCircular* memoriaPartilhada;
HANDLE hSemaforoControlaEscrita;
HANDLE hSemaforoControloLeitura;
HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
int controloDaThread; //flag, 1 sair, 0 caso contrário
int idConsumidor;
}DadosThreads;
//a thread consumidor
DWORD WINAPI ThreadConsumidor(LPVOID param) {
DadosThreads* dados = (DadosThreads*)param;
CelulaBufferCircular celBC; //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
int contadorItensProduzidos = 0;
int soma = 0;
while (dados->controloDaThread == 0) {
//ler no buffer circular,
WaitForSingleObject(
dados->hSemaforoControloLeitura, //existe uma posição para ler
INFINITE
);
//temos a garantia que temos uma posicção de escrita
WaitForSingleObject(
dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que somos nos a ler
//os dois estão desbloqueados e vamos ser o unico consumdior que vai ler
CopyMemory(
&celBC, //copiar
&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoLeitura], //destino
sizeof(CelulaBufferCircular)
);
//a proxima posicao de escrita é incrementada
dados->memoriaPartilhada->proximaPosicaoLeitura++;
//cheguei ao limite volto à posicao 0
if (dados->memoriaPartilhada->proximaPosicaoLeitura == TAM_BUFFER_CIRUCLAR) {
dados->memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//libertar o mutex quando terminamos a leitura
ReleaseMutex(dados->hMutexControloExclusaoMutua);
//libtertar o semaforo de escrita
//se ocupamos uma posição de leitura libertamos uma posição de escrita
//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
ReleaseSemaphore(dados->hSemaforoControlaEscrita, 1, NULL); //apenas uma posição, 1
contadorItensProduzidos++;
soma = soma + celBC.val;
_tprintf(TEXT("\nConsumidor %d consumiu valor %d "), dados->idConsumidor, celBC.val);
//Sleep(numero_aleatorio(2, 4) * 1000);
}
_tprintf(TEXT("\nConsumidor %d consumiu %d acumulado"), dados->idConsumidor, soma);
return 0;
}
int _tmain(int argc, LPSTR argv[]) {
HANDLE hFileMap;
//mapeamento da memoria partilhada
DadosThreads dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
//lidar com o random
srand((unsigned int)time(NULL));
//os semaforos
dados.hSemaforoControlaEscrita = CreateSemaphore(
NULL,
TAM_BUFFER_CIRUCLAR,
TAM_BUFFER_CIRUCLAR,
TEXT("SO2_MEMORIA_ESCRITA")
);
if (dados.hSemaforoControlaEscrita == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
return 1;
}
dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
0, //quantidade de posições iniciais, não existe nada para ser lido
TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
TEXT("SO2_MEMORIA_LEITURA")
);
if (dados.hSemaforoControloLeitura == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
return 1;
}
//exclusao mutua para os produtores
dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_CONSUMIDOR"));
if (dados.hMutexControloExclusaoMutua == NULL) {
_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
return 1;
}
hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
int primeiroProcesso = FALSE;
//se existir é aberto
//se nao existe é nulo
if (hFileMap == NULL) {
//existe um problem é porque se calahar não existe
//criar a memoria partilhada
primeiroProcesso = TRUE;
hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
NULL,
PAGE_READWRITE, //nivel de protecão: lieura e escrita);
0, //dimensões da memoria partilhada: mais significativa
sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
);
if (hFileMap == NULL) {
_tprintf(TEXT("\nerro no CreateFileMapping"));
return 1;
}
}
dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
hFileMap,
FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
0, //offsets: onde é mapeada
0, //0 para mapear até ao final
0 //0 para mapear até ao final
);
if (dados.memoriaPartilhada == NULL) {
_tprintf(TEXT("\nerro no MapViewOfFile"));
return 1;
}
//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
if (primeiroProcesso == TRUE) {
dados.memoriaPartilhada->numeroConsumidores = 0;
dados.memoriaPartilhada->numeroProdutores = 0;
dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//criar a thread
dados.controloDaThread = 0;
//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
//ir à memoria partilhada
dados.memoriaPartilhada->numeroConsumidores++;
dados.idConsumidor = dados.memoriaPartilhada->numeroConsumidores;
//libertar o mutex
ReleaseMutex(dados.hMutexControloExclusaoMutua);
HANDLE hThread;
TCHAR comando[100];
hThread = CreateThread(NULL, 0, ThreadConsumidor, &dados, 0, NULL);
if (hThread != NULL) {
_tprintf(TEXT("escreve qualquer coisa para sair"));
_getts_s(comando, 100);
dados.controloDaThread = 1;
WaitForSingleObject(hThread, INFINITE);
}
UnmapViewOfFile(dados.memoriaPartilhada);
//CloseHandle();
return 0;
}
produtor
//produtor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random
#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular
typedef struct {
int id;
int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular
typedef struct {
int numeroProdutores;
int numeroConsumidores;
int proximaPosicaoEscrita; //controlar
int proximaPosicaoLeitura; //controlar
CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada
typedef struct {
BufferCircular* memoriaPartilhada;
HANDLE hSemaforoControlaEscrita;
HANDLE hSemaforoControloLeitura;
HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
int controloDaThread; //flag, 1 sair, 0 caso contrário
int idProdutor;
}DadosThreads;
//lidar com o random
int numero_aleatorio(int min, int max) {
return rand() % (max - min + 1) + min; //valor entre min e max
}
//a trhead produtor
DWORD WINAPI ThreadProdutor(LPVOID param) {
DadosThreads* dados = (DadosThreads*)param;
CelulaBufferCircular celBC; //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
int contadorItensProduzidos = 0;
while (dados->controloDaThread == 0) {
celBC.id = dados->idProdutor;
//produzir o item
celBC.val = numero_aleatorio(10,99);
//escrever no buffer circular,
WaitForSingleObject(
dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que temos uma posicção de escrita
WaitForSingleObject(
dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
INFINITE
);
//temos a garantia que somos nos a escrever
//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
CopyMemory(
&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
&celBC,
sizeof(CelulaBufferCircular)
);
//a proxima posicao de escrita é incrementada
dados->memoriaPartilhada->proximaPosicaoEscrita++;
//cheguei ao limite volto à posicao 0
if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
}
//libertar o mutex
ReleaseMutex(dados->hMutexControloExclusaoMutua);
//libtertar o semaforo de leitura
//se ocupamos uma posição de escrita libertamos uma posição de leitura
//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1
contadorItensProduzidos++;
_tprintf(TEXT("\nProdutor %d produziu valor %d "), dados->idProdutor, celBC.val);
Sleep(numero_aleatorio(2, 4)*1000);
}
_tprintf(TEXT("\nProdutor %d produziu %d itens"), dados->idProdutor, contadorItensProduzidos);
return 0;
}
int _tmain(int argc, LPSTR argv[]) {
HANDLE hFileMap;
//mapeamento da memoria partilhada
DadosThreads dados;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
//lidar com o random
srand((unsigned int)time(NULL));
//os semaforos
dados.hSemaforoControlaEscrita = CreateSemaphore(
NULL,
TAM_BUFFER_CIRUCLAR,
TAM_BUFFER_CIRUCLAR,
TEXT("SO2_MEMORIA_ESCRITA")
);
if (dados.hSemaforoControlaEscrita == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
return 1;
}
dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
0, //quantidade de posições iniciais, não existe nada para ser lido
TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
TEXT("SO2_MEMORIA_LEITURA")
);
if (dados.hSemaforoControloLeitura == NULL) {
_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
return 1;
}
//exclusao mutua para os produtores
dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_PRODUTOR"));
if (dados.hMutexControloExclusaoMutua == NULL) {
_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
return 1;
}
hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
int primeiroProcesso = FALSE;
//se existir é aberto
//se nao existe é nulo
if (hFileMap == NULL) {
//existe um problem é porque se calahar não existe
//criar a memoria partilhada
primeiroProcesso = TRUE;
hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
NULL,
PAGE_READWRITE, //nivel de protecão: lieura e escrita);
0, //dimensões da memoria partilhada: mais significativa
sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
);
if (hFileMap == NULL) {
_tprintf(TEXT("\nerro no CreateFileMapping"));
return 1;
}
}
dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
hFileMap,
FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
0, //offsets: onde é mapeada
0, //0 para mapear até ao final
0 //0 para mapear até ao final
);
if (dados.memoriaPartilhada == NULL) {
_tprintf(TEXT("\nerro no MapViewOfFile"));
return 1;
}
//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
if (primeiroProcesso == TRUE) {
dados.memoriaPartilhada->numeroConsumidores = 0;
dados.memoriaPartilhada->numeroProdutores = 0;
dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
}
//criar a thread
dados.controloDaThread = 0;
//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
//ir à memoria partilhada
dados.memoriaPartilhada->numeroProdutores++;
dados.idProdutor = dados.memoriaPartilhada->numeroProdutores;
//liberta ro mutex
ReleaseMutex(dados.hMutexControloExclusaoMutua);
HANDLE hThread;
TCHAR comando[100];
hThread = CreateThread(NULL, 0, ThreadProdutor, &dados, 0, NULL);
if (hThread != NULL) {
_tprintf(TEXT("escreve qualquer coisa para sair"));
_getts_s(comando, 100);
dados.controloDaThread = 1;
WaitForSingleObject(hThread, INFINITE);
}
UnmapViewOfFile(dados.memoriaPartilhada);
//CloseHandle();
return 0;
}
repo: atende cliente OverLappedIO
Cliente:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"
DWORD WINAPI leResposta(LPVOID lpData) {
HANDLE hPipe = (HANDLE)lpData;
TCHAR szStr[TAM];
DWORD dwLidos, res;
OVERLAPPED ov;
HANDLE hEvento;
hEvento = CreateEvent(NULL, TRUE, FALSE, NULL); //ultimo NULL evento local à thread não peciso de nome
do {
ZeroMemory(&ov, sizeof(ov));
ov.hEvent = hEvento;
//ResetEvent(hEvent);
res = ReadFile(hPipe, szStr, TAM, &dwLidos, &ov); //nao fico à espera agora, fica agendada a operação
if (res) {
_tprintf(_T("foi realizada de imediato...\n"));
}
if (!res && GetLastError() == ERROR_IO_PENDING) { //proteção
_tprintf(_T("a aguardar informação...\n"));
/* .... */
WaitForSingleObject(ov.hEvent, INFINITE);
GetOverlappedResult(hPipe, &ov, &dwLidos, FALSE);
}
_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
} while (_tcscmp(szStr, _T("SAIR")) != 0);
return 0;
}
int _tmain(int argc, TCHAR* argv[]) {
HANDLE hPipe;
TCHAR szStr[TAM];
DWORD dwEscritos;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
while (1) {
//ligar ao servidor
hPipe = CreateFile(NOME_PIPE,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);
if (hPipe != INVALID_HANDLE_VALUE) {
break;
}
if (!WaitNamedPipe(NOME_PIPE, 10000)) { //espera 10 segundos
_tprintf(_T("[erro] named pipe nao existe "));
}
}
//thread para ler resposta
HANDLE hThread;
DWORD dwTid;
hThread = CreateThread(NULL, 0, leResposta, (LPVOID)hPipe, 0, &dwTid);
OVERLAPPED ov;
HANDLE hEvento;
hEvento = CreateEvent(NULL, TRUE, FALSE, NULL);
//thread inicial
do {
_tprintf(_T("TEXTO: "));
if (_fgetts(szStr, TAM, stdin) == NULL) {
break;
}
szStr[_tcslen(szStr) - 1] = _T('\0');
ZeroMemory(&ov, sizeof(ov)); //limpar
ov.hEvent = hEvento; //atribuir
//ResetEvent(hEvent)//nao é necessário
WriteFile(hPipe, szStr, ((DWORD)_tcslen(szStr) + 1) * sizeof(TCHAR), &dwEscritos, &ov); //envia info para o servidor, e não bloqueia. dwEscritos total de bytes escritos
//devia verificar e
//true correu bem //true: correu bem
//false: correu mal
//getpasteerror, que a oepração foi agendada
/* .. podemos fazer o que quiseremos não é tão critico.. */
WaitForSingleObject(ov.hEvent, INFINITE);//esperar que o evento seja assinalado
GetOverlappedResult(hPipe, &ov, &dwEscritos, FALSE); //esperar que o write foi concluido. dwEscritos verificar se o numero de bytes foram escritos
_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
} while (_tcscmp(szStr, _T("SAIR")) != 0);
return 0;
}
Servidor:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"
DWORD WINAPI atendeCliente(LPVOID lpData) {
HANDLE hPipe = (HANDLE)lpData;
TCHAR szStr[TAM];
DWORD dwLidos, dwEscritos;
_tprintf(_T("Cliente ligado...\n"));
while (1) {
if (!ReadFile(hPipe, szStr, TAM, &dwLidos, NULL)) { //lê pedido..
break;
}
_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
CharUpperBuff(szStr, dwLidos/sizeof(TCHAR)); //processa
WriteFile(hPipe, szStr, dwLidos, &dwEscritos, NULL); //envia resposta
_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
}
_tprintf(_T("O cliente desligou...\n"));
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
return 0;
}
int _tmain(int argc, TCHAR* argv[]) {
HANDLE hPipe;
DWORD dwTid;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
while (1) {
//cada vez que um cliente se ligar é criada uma nova thread
hPipe = CreateNamedPipe(
NOME_PIPE,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
BUFFSIZE,
BUFFSIZE,
10000,
NULL);
if (ConnectNamedPipe(hPipe, NULL)) {
CreateThread(NULL, 0, atendeCliente, (LPVOID)hPipe, 0, &dwTid);
}
}
return 0;
}
Util:
#define TAM 100
#define NOME_PIPE TEXT("\\\\.\\pipe\\teste")
#define BUFFSIZE 1024
repo: atende cliente
Cliente:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"
int _tmain(int argc, TCHAR* argv[]) {
HANDLE hPipe;
TCHAR szStr[TAM];
DWORD dwLidos, dwEscritos;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
while (1) {
//cada vez que um cliente se ligar é criada uma nova thread
hPipe = CreateFile(NOME_PIPE,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hPipe != INVALID_HANDLE_VALUE) {
break;
}
WaitNamedPipe(NOME_PIPE, 10000); //espera 10 segundos
}
do{
_tprintf(_T("TEXTO: "));
if (_fgetts(szStr, TAM, stdin) == NULL) {
break;
}
szStr[_tcslen(szStr) - 1] = _T('\0');
WriteFile(hPipe, szStr, ((DWORD)_tcslen(szStr) + 1) * sizeof(TCHAR), &dwEscritos, NULL);
_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
ReadFile(hPipe, szStr, TAM, &dwLidos, NULL);
_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
} while (_tcscmp(szStr, _T("SAIR")) != 0);
return 0;
}
Servidor:
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"
DWORD WINAPI atendeCliente(LPVOID lpData) {
HANDLE hPipe = (HANDLE)lpData;
TCHAR szStr[TAM];
DWORD dwLidos, dwEscritos;
_tprintf(_T("Cliente ligado...\n"));
while (1) {
if (!ReadFile(hPipe, szStr, TAM, &dwLidos, NULL)) { //lê pedido..
break;
}
_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
CharUpperBuff(szStr, dwLidos/sizeof(TCHAR)); //processa
WriteFile(hPipe, szStr, dwLidos, &dwEscritos, NULL); //envia resposta
_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
}
_tprintf(_T("O cliente desligou...\n"));
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
return 0;
}
int _tmain(int argc, TCHAR* argv[]) {
HANDLE hPipe;
DWORD dwTid;
#ifdef UNICODE
_setmode(_fileno(stdin), _O_WTEXT);
_setmode(_fileno(stdout), _O_WTEXT);
_setmode(_fileno(stderr), _O_WTEXT);
#endif
while (1) {
//cada vez que um cliente se ligar é criada uma nova thread
hPipe = CreateNamedPipe(
NOME_PIPE,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
BUFFSIZE,
BUFFSIZE,
10000,
NULL);
if (ConnectNamedPipe(hPipe, NULL)) {
CreateThread(NULL, 0, atendeCliente, (LPVOID)hPipe, 0, &dwTid);
}
}
return 0;
}
Util:
#define TAM 100
#define NOME_PIPE TEXT("\\\\.\\pipe\\teste")
#define BUFFSIZE 1024
Apontamentos teóricos
::Slides05 – SO2 – 2022 – BibliotecasWindows v18.pdf
O ficheiro .lib (opcional). Usado para os casos de ligação implícita
O ficheiro .DEF (opcional). Método alternativo para identificar as funções em ligação explícita (identificação por número de ordem em vez de pelo nome)
O método mais habitual é o de identificar as funções pelo nome. A identificação posterior por parte dos programas que usam a DLL é feita então de duas formas: ligação implícita e ligação explícita
Em ambos os casos a DLL tem que estar sempre presente durante a execução
Ligação implícita
É usado um ficheiro auxiliar .lib = biblioteca de ligação estática para estabelecer a ponte entre o programa e as funções na DLL
O programa que usa as funções apenas precisa do .h e do .lib durante a compilação e usa as funções quase como se elas fizessem parte do seu código.
Ligação explícita
Não é necessário nenhum .lib, e, eventualmente, nem sequer um .h durante a compilação
O programa que usa a DLL tem que carregar explicitamente a DLL e depois procurar as funções pelo nome, invocando-as por ponteiro.
Código da DLL
Uma DLL é uma variante de um ficheiro executável.
Não se destina a executar por si só.
Age como um repositório de funções e recursos para ser usado por outros programas
Exemplo:
um função na DLL
#include
// Função “local“ -> não vai ser exportada
int factorial (int n) { // calcula factorial de n
int res = n;
n–;
while (n>1) {
res = res * n;
n–;
}
return res;
}
// Variável exportada
__declspec(dllexport) int nExemplo = 0;
// Função exportada
__declspec(dllexport) int fnExemplo(int n) {
if (n<0) n = -1; return factorial(n); } Resultado da compilação exemplo.dll → Código da DLL exemplo.lib → Ficheiro auxiliar para ligação implícita Ligação implícita Forma de uso da DLL que oculta o facto de se estarem a usar recursos externos ao programa. As funções aparentam estar no próprio programa e o seu uso é muito simplificado. A carga da DLL, procura de funções e libertação da DLL são feitas automaticamente por código disponibilizado numa pequena biblioteca de ligação estática (o .lib) que faz a ponte entre o programa e a DLL. O .lib contém funções com o mesmo nome que as existem no .dll, reencaminhando as chamadas para lá A DLL é carregada automaticamente no início da execução e libertada no fim. Se não estiver presente, o programa não corre de todo. A DLL mantem-se sempre em memória e utilizando assim mais memória Nesta forma, os recursos da DLL aparentam estar no programa tal como se de uma biblioteca de ligação estática se tratasse. Na ligação implícita, se a DLL não estiver presente, todo o programa é impedido de correr. Na ligação implícita, o compilador consegue efectuar algumas validações no uso das funções (pela existência do ficheiro .h). Se existirem muitas DLL com ligação implícita, o processo tem um início demorado pois todas essas DLL são carregadas no início. A ligação implícita requer a biblioteca estática para fazer a ponte com a DLL. Na ligação implícita as DLL mantêm-se mapeadas durante a execução do processo. Ligação explícita A DLL é tratada como um conjunto de recursos que é trazida para memória e usada quando é necessário de uma forma explícita e totalmente controlada pelo programador do programa “cliente” da DLL. O programador decide quando é que precisa de carregar a DLL e carrega-a explicitamente e apenas nessa altura O programador obtém acesso aos recursos da DLL procurando explicitamente as funções que precisa e invoca-as através de um ponteiro O programador liberta a DLL quando já não precisa mais dela, libertando recursos ao processo e ao sistema Nesta forma torna-se óbvio ao programador que está a usar recursos externos ao seu programa faz uso da API WIN32: LoadLibrary / LoadLibraryEx GetProcAddress //aceder a uma função/variavel exportada FreeLibrary //liberta o módulo do espaço do processo Se a DLL não estiver presente, ou se houver algum erro que impeça a sua utilização, o programa não tem que terminar. Apenas a funcionalidade associada à DLL fica inviabilizada Na ligação explícita as DLL são carregadas em qualquer altura. A ligação explícita permite carregar as DLL apenas quando necessário e libertá-las assim que não são necessárias. Isto permite poupar recursos ao processo e sistema ::Slides06 – SO2 – 2022 – Threads_v16.pdf Cada processo tem pelo menos uma thread (thread inicial ou principal) A partir de uma thread pode-se lançar outra thread O facto da thread inicial ser a primeira (ou ser chamada de principal) não lhe confere nenhum privilégio em particular sobre outras threads que venham a existir no processo A criação da thread está associada a uma função. Quando essa função terminar, a thread também termina. API32 threads: CreateThread //Cria uma thread nova ExitThread //Termina a thread GetExitCodeThread //Obtém o código de terminação Terminação de um thread (a partir de outra) Usa-se uma variável de condição acessível às threads envolvidas Para simplicidade vai-se assumir que se trata de uma variável global (mas não precisa de ser assim –> ponteiro passado por parâmetro)
Privilégios de acesso:
SYNCHRONIZE, Permite usar o handle em funções de sincronização
THREAD_ALL_ACCESS, Todos os acessos suportados pelo sistema
THREAD_SUSPEND_RESUME, Permite suspender/des-suspender a thread através do handle obtido
::Slides07 – SO2 – 2022 – Sincronizacao v17.pdf
A sincronização em Win32, aplica-se a:
Serialização de acções (coordenação / cooperação)
Competição por acesso a um recurso
Acesso exclusivo a um recurso (exclusão mútua / secções críticas)
é feita através de espera e sinalização em objectos (através dos seus handles):
O handle de um objecto pode ser usado numa função wait
Os objectos podem estar apenas nos estados assinalado / nãoassinalado
Objectos que podem ser usados em sincronização:
Evento (objectos-evento – não confundir com as mensagens WM_….)
Mutexes
Critical Sections
Semáforos
Waitable Timers
Outros objectos que podem ser usados em sincronização:
Processos
Threads
Input de consola
Notificações de alteração
Objectos de Sincronização no API do Windows:
Semáforos
Ferramenta de sincronização quase universal.
Apropriado a quase todos os casos.
Resolve situações de exlusão mútua, competição e coordenação
Em algumas situações não é o mecanismo mais simples ou mais directo
Mutexes
Resolvem situações de exclusão mútua entre threads e entre processos.
Melhor mecanismo para situações de exclusão mútua que envolvam
processos diferentes.
Critical Section
Versão simplificada de mutexes para uso local a um único processo (com várias threads) em situações de exclusão mútua
O API destes objectos foge à forma habitual usada nos restantes
Waitable Timers
Mecanismos apropriados a acontecimentos relacionados com a passagem de intervalos de tempo
Eventos
Objecto de uso não-específico – o significado e forma de utilização depende muito da lógica da aplicação.
Não são apropriados a situações de exclusão mútua. São mais indicados para cenários de cooperação ou coordenação.
Funções de espera:
WaitForSingleObject / WaitForSingleObjectEx
Espera que um determinado objecto esteja assinalado ou que um determinado timeout se esgote (ou que seja recebido uma notificação de I/O completo)
WaitForMultipleObjects / WaitForMultipleObjectEx
Espera por um conjunto de objectos de uma só vez
WaitForSingleObject retorna:
WAIT_ABANDONED // A thread que detinha o objecto terminou sem o libertar
WAIT_OBJECT_0 //O objecto de sincronização foi libertado
WAIT_TIMEOUT //Ocorreu o tempo máximo de espera
Obtenção dos handles para espera nas funções
Na thread que cria os objectos de sincronização:
CreateEvent //(para eventos)
CreateMutex //(para mutexes)
CreateSemaphore // (para semáforos)
Em outras threads:
OpenEvent //(para eventos)
OpenMutex //(para mutexes)
OpenSemaphore //(para semáforos)
Flags de acesso nas funções open:
Semáforos: SEMAPHORE_MODIFY_STATE (SEMAPHORE_ALL_ACCESS)
Eventos: EVENT_MODIFY_STATE (EVENT_ALL_ACCESS)
Mutexes: MUTEX_MODIFY_STATE (MUTEX_ALL_ACCESS)
Timers: TIMER_MODIFY_STATE (TIMER_ALL_ACCESS)
Sincronização com objectos processo e threads:
A função CreateProcess cria um objecto que representa o novo processo.
Inicialmente o objecto está no estado não-assinalado
O estado passa a assinalado quando o processo termina
Idem para threads
Funções mais úteis para este tipo de objecto de sincronização:
WaitForInputIdle //Espera que o processo esteja bloqueado à espera de input
WaitForSingleObject / WaitForSingleObjectEx // Espera que um processo esteja assinalado (ou seja, tenha terminado)
Sincronização com eventos:
Servem para uma thread indicar que “algo” aconteceu a uma ou mais threads que aguardavam por esse algo.
Um objecto evento é um objecto de sincronização cujo estado pode ser assinalado explicitamente com a função SetEvent
os eventos podem ser usados:
Reset manual (“passam todos até alguém fechar”)
Auto-reset (“só passa o primeiro”)
funções:
HANDLE CreateEvent(..)
HANDLE OpenEvent(..)
BOOL SetEvent(..) //fica assinalado
BOOL ResetEvent(..) //fica não assinalado
Sincronização com mutexes:
Permitem a duas ou mais threads (ou processos) aguardarem por acesso a uma zona de código (”seção crítica”) que manipula um recurso (ex., dados)
Um objecto mutex permite resolver directamente as situações de exclusão mútua
Encontra-se no estado assinalado quando nenhuma thread o possui
Assim que uma thread obtém a sua posse (através das funções de espera), o estado do mutex passa a não-assinalado
Uma thread que tenha a posse de um mutex pode libertá-lo através da função ReleaseMutex. O mutex em questão passa ao estado assinalado
HANDLE CreateMutex(..) //cria ou obtem acesso a um mutex com ou sem nome (NULL), sem nome só ficam restringidos a threads do mesmo processo.
HANDLE OpenMutex(..) //acesso ao mutex
BOOL ReleaseMutex(..) // libterta a possse do mutex
Sincronização com Critical Sections:
podem ser partilhados por processos diferentes. Servem apenas para sincronização de threads dentro do mesmo processo.
Sincronização com semáforos:
Generalização do conceito de mutex – Permite acesso a mais do que um processo/thread em simultâneo
é mantida a contabilização de operações esperar/assinalar que sobre ele são efectuadas
Podem ter nome o que permite que sejam usados por processos diferentes
as funções de espera efectuam a operação de espera sobre o semáforo, decrementando o seu contador interno. Se o contador atinge o valor zero, o estado do semáforo passa a não-assinalado e a thread que que efectuou a espera fica bloqueada
A função ReleaseSemaphore permite efectuar a operação assinalar num semáforo. Uma das thread que estavam bloqueadas à espera nesse semáforo é desbloqueada
funções:
HANDLE CreateSemaphore(..) // cria ou obtem acesso a um semáforo com ou sem nome (NULL)
HANDLE OpenSemaphore(..) //obtem um handle para uma semáforo que existe
BOOL ReleaseSemaphore(..) // Incrementa o contador interno do semáforo na especificada no parâmetro lReleaseCount
::Slides08 – SO2 – 2022 – FicheirosMapeados v16.pdf
Ficheiros mapeados em memória – Memória partilhada
O mecanismo de ficheiros mapeados permite duas funcionalidades:
Mapear (parte de) um ficheiro em memória, operando sobre ele como se se tratasse de uma matriz de bytes
Partilhar um bloco de memória entre processos para situações de comunicação entre processos
Restrições ao uso de ficheiros mapeados:
Manipulação do conteúdo da memória partilhada quando usada para comunicar entre processos (uso em simultâneo em vários processos):
Apenas se pode colocar informação que faça sentido em todos os processos envolvidos.
estão excluídas coisas que só façam sentido no processos que as criou, tais como handles e ponteiros
Uso em simultâneo (concorrente) da mesma memória partilhada por vários processos/threads
Trata-se de um caso típico de acesso concorrente a dados partilhados
Normalmente exigirá o uso de mutexes/semáforos para garantir que duas threads/processos não destroem o trabalho uma da outra e para garantir que o conteúdo dos dados permanece coerente
Uso de ficheiros mapeados:
1 – Obtém handle para o ficheiro
CreateFile //(indica-se o ficheiro)
2 – Criar o objecto FileMapping usando o handle anterior (handle do ficheiro)
CreateFileMapping // (indica-se o handle e o tamanho)
3 – Mapear uma vista do ficheiro no seu espaço de endereçamento
MapViewOfFile //(indica-se a zona pretendida e obtém-se um ponteiro)
4 – Usa a memória partilhada através da vista (sintaxe habitual ponteiros * -> [ ] )
5 – Desmapeia a vista
UnmapViewOfFile //(indica-se o ponteiro)
6 – Fecha o handle do objeto Ficheiro Mapeado
CloseHandle //(handle do filemapping)
7 – Fecha o handle do ficheiro
CloseHandle //(handle do ficheiro)
assim, m processo, inicialmente:
1 – Cria um objecto memória partilhada, obtendo um handle
CreateFileMapping
2 – Mapeia uma vista da memória partilhada no seu espaço de endereçamento
MapViewOfFile
3 – Usa a memória partilhada através da vista (ponteiros ou [ ] )
4 – Desmapeia a vista, eventualmente no final do processo
UnmapViewOfFile
4 – Fecha o handle
CloseHandle
e outro/restantes processos:
1 – Obtém handle para o objecto memória partilhada
OpenFileMapping
2 – Mapeia uma vista da memória partilhada no seu espaço de
endereçamento
MapViewOfFile
3 – Usa a memória partilhada através da vista (ponteiros ou [ ] )
4 – Desmapeia a vista, eventualmente no final do processo
UnmapViewOfFile
5 – Fecha o handle
CloseHandle
funções:
HANDLE WINAPI CreateFileMapping (..) //Esta função é usada para criar um objecto de memória partilhada.
HANDLE WINAPI OpenFileMapping(..) // Esta função é usada para obter acesso ao objecto de memória partilhada (dado o seu nome) criado (normalmente) por outro processo/thread.
LPVOID WINAPI MapViewOfFile (..) //esta função mapeia uma porção da memória partilhada, devolvendo o ponteiro para onde ficou mapeada a vista
LPVOID WINAPI UnmapViewOfFile(..) //Esta função desmapeia uma vista do espaço de endereçamento do processo que a invoca –> o processo deixa de “ver” essa zona de memória partilhada
::Slides09 – SO2 – 2022 – Sincronizacao – Prod-Cons v12.pdf
Produtor/Consumidor – Resolução com recurso a semáforos
Sincronização:
1. Sistemas compostos por mais do que uma entidade activa (processos, threads) que usam recursos e dados partilhados entre si exigem a coordenação do acesso a recursos e dados
2. Sistemas compostos por mais do que uma entidade activa em que uma das entidades é dependente de acontecimentos originados por outra(s) vai exigir mecanismos para coordenar a sua execução em função da execução das outras entidades
Exemplos concretos da vida real
Sistemas cliente servidor envolvendo vários utilizadores ou postos; programas multi-threaded
Situações típicas (exemplos) que envolvem sincronização
Cooperação
Diversas actividades concorrem para a conclusão de uma aplicação comum
Situação que pode ser resolvida algoritmicamente para as aplicações envolvidas com recurso a mecanismos do sistema de suspensão e sinalização
Os processos querem sincronizar as suas acções de forma explícita uns com os outros. Em vez de competição e autorização para avançar, podem voluntariamente auto-suspenderem-se até receberem uma notificação
Competição
Diversos processos competem pela obtenção de um recurso limitado
A competição deve ser resolvida de forma a que o recurso seja utilizado de forma coerente
É complicado e/ou ineficiente resolver esta situação sem ajuda do sistema operativo
Pode ser visto como uma generalização da exclusão mútua: A competição é feita sobre recursos com mais do que uma unidade.
A sincronização é concretizada pelo SO para manter a coerência
Exclusão mútua
A utilização concorrente de uma zona de dados (ou recurso) partilhada pode levar a que os dados fiquem inconsistentes
A utilização desses dados (ou recurso) deve ser feita de uma forma exclusiva: apenas uma entidade activa utiliza o recurso.
A execução de uma secção de código que manipula dados partilhados constitui uma situação típica de acesso em exclusão mútua
Este caso é muito frequente e muito importante. Está também na base da tomada de decisões críticas que podem ter um resultado incorrecto se não for devidamente acautelado
Semáforo:
Constituído por uma estrutura de dados que inclui
Variável de controlo (inteira) = número de autorizações restantes
Fila de espera (de processos / threads bloqueados)
o semáforo bloqueia o processo (thread) e não ocupa o processador
Elimina a espera activa
tipos de semáforos:
Semáforo binário ou MUTEX, Tem apenas uma “autorização” – serve essencialmente para resolver situações de exclusão mútua
Semáforo, Genérico. Permite n “autorizações”, Usado para qualquer tipo de situação (inclusive exclusão mútua). Uso comum em situações de competição e controlo de recursos (por exemplo, cenário produtor/consumidor)
As operações fundamentais sobre semáforos são
Esperar – Requisita o recurso / Requisita uma autorização / (pede acesso a uma secção crítica)
Assinalar – Liberta o recurso / Devolve uma autorização / (liberta a secção crítica)
Método
Cada semáforo tem um contador interno. As operações sobre o semáforo são as de esperar (diminuir o contador) e assinalar (aumentar o contador). Esse contador actua como número de processos que ainda podem passar sem ficarem bloqueados.
Distinguir entre semáforos para exclusão mútua e semáforos para gestão de recursos
Lógica de funcionamento interno de um semáforo
Esperar(Semáforo) //Decrementa a variável de controlo
Assinalar(Semáforo) //Incrementa a variável de controlo
exemplo:
optimizado
Semáforo sem = CriarSemaforo(1);
/* … */
int escreve(tipo_dados valor) {
esperar(sem);
var_partilhada=valor;
assinalar(sem);
}
Produtor/Consumidor – versão com buffer circular, exemplo:
#define DIM … /* tamanho do buffer */
typedef … item; /* a estrutura exacta não é importante */
item buffer[DIM]; /* apenas para simplificação da exposição */
int in, out; /* assumir que DIM cabe em “int” */
/* inicialização (”Semaforo” já definido algures) */
Semaforo sem_mutex_p, sem_mutex_c;
Semaforo sem_itens; // garante que nunca um consumidor tentará utilizar a mesma posição no buffer que um produtor.
Semaforo sem_vazios; // garante que nunca um produtor tentará utilizar a mesma posição no buffer que um consumidor.
/* inicialização */
in = out = 0;
sem_mutex_p = criar_semaforo(1); // 1 -> semáforo de exclusão mútua
sem_mutex_c = criar_semaforo(1); // 1 -> semáforo de exclusão mútua
sem_itens = criar_semaforo(0); // 0 itens produzidos inicialmente
sem_vazios = criar_semaforo(DIM); // DIM elementos disponíveis
Produtor
while (COND) {
item_p = produz_item();
esperar(&sem_vazios); // contabilizar o número de elementos livres no buffer
esperar(&sem_mutex_p); //semáforo de exclusão mútua produtores
buffer[in] = item_p;
in = (in + 1) % DIM;
assinalar(&sem_mutex_p); //semáforo de exclusão mútua produtores
assinalar(&sem_itens); // semáforo para contabilizar o número de itens disponíveis
}
Consumidor
while (COND) {
esperar(&sem_itens); // semáforo para contabilizar o número de itens disponíveis
esperar(&sem_mutex_c); //semáforo de exclusão mútua consumidores
item_c = buffer[out];
out = (out + 1) % DIM;
assinalar(&sem_mutex_c); //semáforo de exclusão mútua consumidores
assinalar(&sem_vazios); // contabilizar o número de elementos livres no buffer
trata_item(item_c);
}
::Slides10 – SO2 – 2022 – NamedPipes v16.pdf
Comunicação interprocesso em Win32 com Named Pipes
Os named pipes podem ser:
De uma só via, O processo ou lê ou escreve (mas não ambos) na sua extremidadedo pipe
De duas vias (pipe duplex), O processo pode ler e escrever na sua extremidade do pipe (mas não ao mesmo tempo: tem que se gerir a sequência de leituras/escritas)
Operações do lado dos servidor:
Criação: CreateNamedPipe
Esperar ligação de um cliente: ConnectNamedPipe
Escrita/leitura: ReadFile / WriteFile
Operações do lado do cliente
Associação a um pipe existente: CreateFile ou CallNamedPipe
Esperar que um servidor esteja à escuta num pipe: WaitNamedPipe
Escrita/leitura: ReadFile / WriteFile
funções:
HANDLE WINAPI CreateNamedPipe(..) //criar namedPipe
BOOL WINAPI ConnectNamedPipe(..) //esperar ligação
BOOL WINAPI DisconnectNamedPipe(..) //terminar ligação
no Servidor:
CreateNamedPipe para criar a primeira instância (e seguintes) do named pipe
ConnectNamedPipe para aguardar um pedido de ligação à instância do named pipe. O atendimento dessa instância pode ser feito numa thread independente, libertando o servidor para criar outra instância e aguardar + processar outro cliente nela
FlushFileBuffers Para desligar do cliente, o servidor aguarda que os dados já tenham sido lidos pelo cliente.
DisconnectNamedPipe Após este passo pode-se desligar a instância do pipe
CloseHandle
no Cliente:
CreateFile para obter um handle (do lado cliente) para uma instância do named pipe
WaitNamedPipe aguardar que exista uma instância do servidor do pipe disponível (= aguardar que o servidor faça um ConnectNamedPipe). Cada cliente que se liga consome (ocupa) uma instância
O cliente interage com o servidor de acordo com um protocolo qualquer predefinido para essa aplicação cliente-servidor
O cliente termina a interação fechando os handles (com reflexo no servidor).
Acerca dos modos
PIPE_READMODE_BYTE
PIPE_READMODE_MESSAGE
Têm que bater certo no lado do servidor e no lado do cliente
PIPE_TYPE_BYTE – PYPE_READMODE_BYTE
PIPE_TYPE_MESSAGE – PYPE_READMODE_MESSAGE
Modo BYTE
O sistema não se preocupa com a fronteira entre mensagens: é tudo uma byte stream
Modo MESSAGE
O sistema percebe que um write corresponde a uma mensagem e ajuda a gerir na leitura. no caso em que se enviam mensagens de tipo e tamanho previamente conhecido
exemplo:
//o servidor
#include
#include
#define BUFSIZE 4096
int _tmain(int argc, TCHAR *argv[]) {
BOOL fConnected;
DWORD dwThreadId;
HANDLE hPipe, hThread;
LPTSTR lpszPipename = TEXT(“\\\\.\\pipe\\mynamedpipe”);
while (1) {
hPipe = CreateNamedPipe(
lpszPipename, // nome do pipe
PIPE_ACCESS_DUPLEX, // acesso read/write (duplex)
PIPE_TYPE_MESSAGE | // pipe to tipo message
PIPE_READMODE_MESSAGE | // modo message-read
PIPE_WAIT, // modo “blocking”
PIPE_UNLIMITED_INSTANCES, // max. instâncias
BUFSIZE, // tam. buffer output
BUFSIZE, // tam. Buffer input
NMPWAIT_USE_DEFAULT_WAIT, // time-out para o cliente
NULL); // atributos segurança default
if (hPipe == INVALID_HANDLE_VALUE) {
_tprintf(TEXT(“CreatePipe falhou”));
return 0;
}
// Aguarda a ligação de um cliente
fConnected = ConnectNamedPipe(hPipe, NULL);
if (!fConnected && (GetLastError() == ERROR_PIPE_CONNECTED) )
fConnected = TRUE;
if (fConnected) {
// atender o cliente (apresentado mais adiante)
AtendeCliente(hPipe) // feita mais adiante
// Este exemplo, não sendo multi-thread
// implica que só trata 1 cliente de cada vez (em série)
}
else
// Este cliente não se conseguiu ligar
// por isso fecha-se o pipe (continua para o prox cliente)
CloseHandle(hPipe);
// Próxima iteração -> mais uma instância e possível cliente
} // ciclo principal (apenas depois de ter atendido este cliente)
return 1;
} // fim do programa servidor
//o cliente
void AtendeCliente (HANDLE hPipe) {
char chRequest[BUFSIZE];
char chReply[BUFSIZE];
DWORD cbBytesRead, cbReplyBytes, cbWritten;
BOOL fSuccess;
while (1) { // ciclo p/ permitir haver N x pergunta-resposta)
// Lê dados do cliente via pipe. // mas cliente só vai fazer 1x
fSuccess = ReadFile(
hPipe, // handle para o pipe
chRequest, // buffer para receber os dados
BUFSIZE * sizeof(char), // tam do buffer (bytes a ler)
& cbBytesRead, // num. de bytes lidos
NULL); // não é overlapped I/O
// se não houver mais dados sai
if (! fSuccess || cbBytesRead == 0) break;
// Escreve a resposta para o pipe
fSuccess = WriteFile(
hPipe, // handle para o pipe
chReply, // buffer com os dados
cbReplyBytes, // num. de bytes a escrever
& cbWritten, // num. de bytes escritos
NULL); // não é overlapped I/O
// verifica operação efectuada
if (! fSuccess || cbReplyBytes != cbWritten)
break;
} // fim do ciclo de escrita
// faz flush ao pipe para garantir que o cliente já leu tudo
// antes de desligar esta instância do pipe
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
} // fim do atendimento deste cliente
#include
#include
#define BUFSIZE 512
int _tmain(int argc, TCHAR *argv[]) {
HANDLE hPipe;
LPTSTR lpvMessage;
TCHAR chBuf[BUFSIZE];
BOOL fSuccess;
DWORD cbRead, cbWritten, dwMode;
LPTSTR lpszPipename = “\\\\.\\pipe\\mynamedpipe”;
lpvMessage = argv[1]; // msg dada na linha de comando
// tenta repetidamente abrir o named pipe (em ciclo)
// espera se for preciso
while (1) { // o ciclo é só para abrir ligação com servidor
hPipe = CreateFile( // tenta obter um handle para o pipe
lpszPipename, // nome do pipe
GENERIC_READ | // acesso read & write
GENERIC_WRITE,
0, // sem “sharing”
NULL, // attributos segurança default
OPEN_EXISTING, // deve abrir um pipe já existente
0, // atributos default
NULL); // sem “ficheiro” “template”
// se obteve um handle válido, sai do ciclo
if (hPipe != INVALID_HANDLE_VALUE)
break; // pipe aberto -> sai do ciclo
// erro = outro que não PIPE_BUSY -> desiste
if (GetLastError() != ERROR_PIPE_BUSY) {
printf(“Não foi possível abrir o pipe”);
return 0; // num programa real: não terminar logo a
} // aplicação. Pode dar para fazer outras tarefas
// ERROR_PIPE_BUSY – todas as instâncias estavam ocup.
// tenta mais 1 (ou N) vezes mas espera entre cada tent.
// (espera 20 segundos “porque sim” – é só um exemplo )
// isto é uma estratégia definida pelo programador
// e podia ser diferente
if (!WaitNamedPipe(lpszPipename, 20000)) {
printf(“não foi possivel abrir o pipe”);
return 0;
}// O ciclo serve para tentar várias vezes porque o serv
// pode estar ocupado. Pode-se sair após N tentativas.
// Com serv multi-threaded este ciclo é menos importante
// o ciclo termina quando consegue abrir o pipe
// sai do ciclo via break (mais atrás)
} // fim do ciclo while em que tenta ligar ao pipe
// Neste momento o pipe está ligado ao servidor
// mudar para modo de leitura de mensagem
// porque foi esse o modo (MESSAGE) usado no servidor
dwMode = PIPE_READMODE_MESSAGE;
fSuccess = SetNamedPipeHandleState(
hPipe, // handle para o pipe
& dwMode, // novo pipe mode
NULL, // maximum bytes = NULL (não altera)
NULL); // maximum time = NULL (não altera)
if (!fSuccess) {
printf(“SetNamedPipeHandleState falhou”);
return 0;
}
// lógica de interação nesta aplicação (servidor é diferente)
// -> cliente escreve 1 msg, servidor responde, fim
// 1º: cliente escreve,
// 2º cliente lê
// 1º Escrever uma mensagem no pipe
fSuccess = WriteFile( // no exemplo: envia sempre chars
hPipe, // handle para o pipe
lpvMessage, // mensagem
(lstrlen(lpvMessage)+1)*sizeof(TCHAR), // tam da msg
&cbWritten, // bytes escritos
NULL); // não é uma operação overlapped
if (!fSuccess) {
_tprintf(TEXT(“WriteFile falhou“));
return 0;
}
// 2º Ler dados do pipe
do {
fSuccess = ReadFile(
hPipe, // handle para o pipe
chBuf, // buffer para receber os dados
BUFSIZE * sizeof(TCHAR), // tam. do buffer
& cbRead, // num. bytes a ler
NULL); // não é overlapped
// se não houver mais dados sai
if (! fSuccess && GetLastError() != ERROR_MORE_DATA)
break;
printf(“%s\n”, chBuf ); // mostra informação lida
} while (!fSuccess); // repete até não haver mais dados
// = “até a resposta terminar” (o serv não envia mais nada)
CloseHandle(hPipe);
return 0;
} // fim do exemplo
::Slides11 – SO2 – 2022 – AppGraficasWin32 v23.pdf
Como chegar aos dados da janela em questão a partir do handle?
Colocar os dados em questão numa variável estruturada.
Colocar na estrutura do Windows que descreve a janela um ponteiro para essa variável estruturada com os dados em questão (reservando espaço para tal na estrutura WNDCLASSEX)
1) Registar o ponteiro para a estrutura com os dados nos bytes extra associados à janela
wcl.cbWndExtra = sizeof(EstruturaDados *);
2) Colocação de um ponteiro (criação da janela / na função main)
EstruturaDados dados; …
SetWindowLongPtr(hwnd, 0, (LONG_PTR) &dados);
3) Obtenção do ponteiro (na função da janela)
EstruturaDados * pont = (EstruturaDados *) GetWindowLongPtr(hwnd, 0);
A função da janela é modificada da seguinte maneira:
WM_CREATE,
WM_LBUTTONDOWN
WM_MOUSEMOVE
WM_LBUTTONUP
WM_PAINT