|
контейнеры STL и многопоточность
#34569204
Ссылка:
Ссылка на сообщение:
Ссылка с названием темы:
Ссылка на профиль пользователя:
|
|
|
|
|
OLEG_2005Здесь упоминали семафоры для решения данной задачи, инересно, а каким образом для решения задачи можно применить световоры?
Вот упрощенная версия, работает только в Unix.
[SRC locks.h]
/**************************=-OpenDSA-=******************************
This file is a part of OpenDSA project(http://sourceforge.net/projects/opendsa)
It can be destributed independently of OpenDSA with safe license of
OpenDSA. OpenDSA is destributed by GPL license.
(04.06.2006).
All rights reserved by (C) Konstantin Kaduk 2006.
*******************************************************************/
#include <stdio.h> // standard I/O routines.
#include <sys/types.h> // various type definitions.
#include <sys/ipc.h> // general SysV IPC structures
#include <sys/sem.h> // shared memory functions and structs.
#include <errno.h>
#include <string.h>
/*******************************************************************
*******************************************************************/
#ifndef SEM_LOCK_H
#define SEM_LOCK_H
extern int rc; // any results
#define MAXSETSIZE 3
/*******************************************************************
*******************************************************************/
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
/* Linux specific part: */
struct seminfo *__buf; /* buffer for IPC_INFO */
};
/*******************************************************************
*******************************************************************/
#define LOC_SEM_CNT 3
class c_lock
/*******************************************************************
Class c_lock provide objects locking for reading and writing
1. READ locking
Any concurent processes can read data which locked by another.
Each process incerase semaphore(0) counter for place reading lock.
When write lock was placed(semaphore(1)) by another process
reading process will sleep while writing lock will be dropped.
Counter is decreased when reding lock is dropped by current process.
2. Write locking
Writing process sleeps while any another process is reading or writing
data now.It wake ups when counter(semaphotre 1) of reading process
is equal to zero. It places writing lock by two semaphores(1,2):
Semaphore 1 is used for place writing lock (using for check by
reading processes).
Semaphore 2 is used for exclusive lock(only one process can use data
at the same time).
////////End of original coment form Konstantin Kaduk ////////////////////////
Remark1:
///////
*******************************************************************/
{
int s_set_id;
struct sembuf s_sem_op[LOC_SEM_CNT];
union semun s_semun;
unsigned short s_semarray[LOC_SEM_CNT]; //array for semop
public:
c_lock(int sem_id=0);
~c_lock();
int lock_init(int sem_id);
void stat(const char* f_comment=NULL ); // print current values of semaphore
void r_lock(); // place reading lock
void r_unlock(); // decrease reading counter
void w_lock(); // place writing lock
void w_unlock(); // drop writing lock
};
#endif
[/src]
[SRC locks.cpp]
/**************************=-OpenDSA-=******************************
This file is a part of OpenDSA project(http://sourceforge.net/projects/opendsa)
It can be destributed independently of OpenDSA with safe license of
OpenDSA. OpenDSA is destributed by GPL license (04.06.2006).
All rights reserved by (C) Konstantin Kaduk 2006.
*******************************************************************/
#include "sem_lock.h"
/******************************************************************
*******************************************************************/
c_lock::c_lock(int sem_id):s_set_id(0)
{
if(sem_id!=0)
lock_init(sem_id);
};
/******************************************************************
*******************************************************************/
c_lock::~c_lock()
{
int rc=semctl(s_set_id, 0, IPC_RMID);
};
/******************************************************************
*******************************************************************/
int c_lock::lock_init(int sem_id)
{
printf("initing semaphore lock [%d]\n", sem_id);
s_set_id = semget(sem_id, 3, IPC_CREAT | 0600);
if(s_set_id==-1)
{
printf("Unable to allocate semaphore errno %d [%s]\n",errno, strerror(errno));
throw int(10);
};
s_semun.array=&s_semarray[0];
s_semarray[0]=0; //reading
s_semarray[1]=0; //writing
s_semarray[2]=1; // spin lock
rc = semctl(s_set_id, 3, SETALL, s_semun );
if(rc == -1)
{
printf("Problem to set sem value %d [%s]\n",errno, strerror(errno));
throw int(11);
};
return 0;
};
/******************************************************************
*******************************************************************/
void c_lock::stat( const char* f_comment)
{
s_semun.array=&s_semarray[0];
int rc = semctl(s_set_id, 0,GETALL, s_semun);
if (f_comment!=NULL) printf("****** %s ******\n", f_comment);
printf("SEM values READ WRITE WRSPIN\n");
printf(" [%d] [%d] [%d] \n", s_semarray[0], s_semarray[1], s_semarray[2]);
printf("*********************************\n");
};
/******************************************************************
*******************************************************************/
void c_lock::r_lock()
{
struct sembuf sem_op;
stat( "before read lock");
//increse for reading
s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = 1; //increase read value
s_sem_op[0].sem_flg = 0;//IPC_NOWAIT;
//check for write
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = 0; // check for write
s_sem_op[1].sem_flg = 0;//IPC_NOWAIT;
rc=semop(s_set_id, &s_sem_op[0], 2);
stat("read locked");
};
/******************************************************************
*******************************************************************/
void c_lock::r_unlock()
{
struct sembuf sem_op;
stat("read unlocking");
s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = -1; //decrease reading value
s_sem_op[0].sem_flg = 0;
rc=semop(s_set_id, &s_sem_op[0], 1);
stat(" read unlocked");
};
/******************************************************************
*******************************************************************/
void c_lock::w_lock()
{
stat("write locking");
//increse for read
s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = 0;
s_sem_op[0].sem_flg = 0;//IPC_NOWAIT;
//check for write
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = 1; // check for write
s_sem_op[1].sem_flg = 0;//IPC_NOWAIT;
s_sem_op[2].sem_num = 2;
s_sem_op[2].sem_op = -1; // set for exclusive
s_sem_op[2].sem_flg = 0;//IPC_NOWAIT;
rc=semop(s_set_id, &s_sem_op[0], 3);
stat("write locked");
};
/******************************************************************
*******************************************************************/
void c_lock::w_unlock()
{
stat("write unlocking");
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = -1;
s_sem_op[1].sem_flg = 0;
s_sem_op[2].sem_num = 2;
s_sem_op[2].sem_op = 1; // check for spin write
s_sem_op[2].sem_flg = 0;//IPC_NOWAIT;
rc=semop(s_set_id, &s_sem_op[1], 2);
stat("write unlocked");
};
[/SRC]
|
|
|
