FoxPro/Visual FoxPro - ALGORITMO DE LECTORES Y ESCRITORES

HOLA, NECESITO AYUDA PARA REPRESENTAR EL ALGORITMO DE LECTORES Y ESCRITORES POR MEDIO DE VISUAL.NET, Y REPRESENTADO POR MEDIO DE UNA BASE DE DATOS, ES DECIR QUE SI HAY ALGUIEN ESCRIBIENDO Y LLEGA UN LECTOR ESTE TENGA QUE ESPERAR A QUE EL ESCRITOR SALGA.
IGUALMENTE CUALES PAQUETES NECESITO.
AGRADEZCO CUALQUIER AYUDA.

hola, necesito el codigo de LECTORES Y ESCRITORES en c,utilizando semáforos no hilos, por favor agradeceria si me lo puedieran pasar

este es el codigo que tengo, tiene semaforos pero no tiene hilos. Ah otra cosa estoy haciendo un trabajo practico y me falta mucha documentacion hacerca de los origenes de este algoritmo por favor si tienes algo por favor enviamelo.

//CABECERA DE CLASE MONITORBD
class SeccionCritica
{
private:

//ATRIBUTOS PRIVADOS
#ifdef DGB_WIN32

CRITICAL_SECTION m_csAccesoTablas;

#else //DGB_LINUX

pthread_mutex_t m_AccesoTablas;

#endif

//CONSTRUCTOR
public:

SeccionCritica();

//METODOS PUBLICOS
public:

void InicializarSeccionCritica();
void EntrarSeccionCritica();
void SalirSeccionCritica();
void EliminarSeccionCritica();
};

//IMPLEMENTACION SECCIONCRITICA
void SeccionCritica::InicializarSeccionCritica()
{
#ifdef DGB_WIN32

InitializeCriticalSection(&m_csAccesoTablas);

#else //DGB_LINUX

pthread_mutex_init(&m_AccesoTablas,NULL);

#endif
}

void SeccionCritica::EntrarSeccionCritica()
{
#ifdef DGB_WIN32

EnterCriticalSection(&m_csAccesoTablas);

#else //DGB_LINUX

pthread_mutex_lock(&m_AccesoTablas);

#endif
}

void SeccionCritica::SalirSeccionCritica()
{
#ifdef DGB_WIN32

LeaveCriticalSection(&m_csAccesoTablas);

#else //DGB_LINUX

pthread_mutex_unlock(&m_AccesoTablas);

#endif
}

void SeccionCritica::EliminarSeccionCritica()
{
#ifdef DGB_WIN32

DeleteCriticalSection(&m_csAccesoTablas);

#endif
}

//CABECERA DE CLASE MONITORBD
class MonitorBD
{
private:

SeccionCritica m_SeccionCritica;
int m_iNumeroLectores;
int m_iIdThreadEscritor;

#ifdef DGB_LINUX
sem_t m_Mutex;
sem_t m_Cola;
#else
HANDLE m_hMutex;
HANDLE m_hCola;
#endif


public:

MonitorBD();
~MonitorBD();

int InicioPeticionLectura();
int FinPeticionLectura();

int InicioPeticionEscritura();
int FinPeticionEscritura();

};

//IMPLEMENTACION MONITORBD
//Clase MonitorBD
MonitorBD::MonitorBD()
{
m_SeccionCritica.InicializarSeccionCritica();
m_iNumeroLectores = 0;
m_iIdThreadEscritor = -1;

#ifdef DGB_LINUX
sem_init(&m_Mutex, 0, 1);
sem_init(&m_Cola, 0, 1);
#else
m_hMutex = CreateMutex(0, FALSE, 0);
m_hCola = CreateSemaphore(0, 1, 1, 0);
#endif

}

//-------------------------------------------------------------------

int MonitorBD::InicioPeticionLectura()
{
#ifdef DGB_LINUX

sem_wait(&m_Mutex);
#else
WaitForSingleObject(m_hMutex, INFINITE);
#endif

m_iNumeroLectores++;

if(m_iNumeroLectores == 1)
#ifdef DGB_LINUX
sem_wait(&m_Cola);

sem_post(&m_Mutex);
#else
WaitForSingleObject(m_hCola, INFINITE);

ReleaseMutex(m_hMutex);
#endif

return 0;
}

//-------------------------------------------------------------------

int MonitorBD::FinPeticionLectura()
{

#ifdef DGB_LINUX
sem_wait(&m_Mutex);
#else
WaitForSingleObject(m_hMutex, INFINITE);
#endif

m_iNumeroLectores--;

if(m_iNumeroLectores == 0)
#ifdef DGB_LINUX
sem_post(&m_Cola);

sem_post(&m_Mutex);
#else
ReleaseSemaphore(m_hCola, 1, 0);

ReleaseMutex(m_hMutex);
#endif

return 0;
}

//-------------------------------------------------------------------

int MonitorBD::InicioPeticionEscritura()
{
#ifdef DGB_LINUX
sem_wait(&m_Cola);
#else
WaitForSingleObject(m_hCola, INFINITE);
#endif

return 0;
}

//-------------------------------------------------------------------

int MonitorBD::FinPeticionEscritura()
{
#ifdef DGB_LINUX
sem_post(&m_Cola);
#else
ReleaseSemaphore(m_hCola, 1, 0);
#endif

return 0;
}

//-------------------------------------------------------------------
MonitorBD::~MonitorBD()
{
m_SeccionCritica.EliminarSeccionCritica();
#ifdef DGB_LINUX

#else
CloseHandle(m_hMutex);
CloseHandle(m_hCola);
#endif
}


INT32 ObtenerIdThreadActual()
{
#ifdef DGB_WIN32
return GetCurrentThreadId();
#else
return thr_self();
#endif
}


//Re: Lectores/Escritores
by kelfis on Thursday February 17, @12:49PM

Lo que puedes hacer es que cada vez que hagas una petición escritura, te guardes en el monitor el identificador del thread que hace la peticion. Cada vez que leas, pregunta por ese identificador y si es el del escritor, no te bloquees.
Te adjunto el código del algoritmo, en C++, que hace lo que pides; sólo tienes que incluir la llamada a ObtenerIdThreadActual() donde quieras protegiéndola con la seccion critica.
Además, es compatible para WIN32 y UNIX.
La sección crítica es para proteger dentro del monitor la variable del identificador del thread.
También te mando en código.

No olvides incluir las cabeceras (thread.h, dirent.h, windows.h..........).

Espero que te sirva.

Un saludo.
Codigo.txt
3KB (3792 bytes)


[ Reply to this ]

The Fine Print: The following comments are owned by whoever posted them.
( Reply )

necesito un algoritmo de reconocimiento facial en fox