Was ist die Verwendung von Semaphor in Swoole?

In Swoole werden Semaphore hauptsächlich zum Schutz gemeinsam genutzter Ressourcen verwendet, sodass jeweils nur ein Prozess vorhanden ist, wenn der Wert des Semaphors positiv ist. Dies bedeutet, dass der zu testende Thread für die Verwendung gesperrt werden kann Das Semaphor ist 0. Dies bedeutet, dass der getestete Thread in die Schlafwarteschlange eintritt und darauf wartet, geweckt zu werden.

Die Betriebsumgebung dieses Tutorials: Windows 10-System, Swoole 4-Version, DELL G3-Computer

Was ist die Verwendung von Semaphoren in Swoole?

Die Verwendung von Semaphoren wird hauptsächlich zum Schutz gemeinsam genutzter Ressourcen verwendet dass Ressourcen jeweils nur im Besitz eines Prozesses (Thread) verwendet werden können

. Wenn der Wert des Semaphors positiv ist, bedeutet dies, dass es inaktiv ist. Der getestete Thread kann während der Verwendung sperren. Wenn es 0 ist, bedeutet dies, dass es belegt ist und der Testthread in die Schlafwarteschlange eintritt und darauf wartet, geweckt zu werden.

Linux bietet zwei Arten von Semaphoren:

(1) Kernel-Semaphoren, die vom Kernel-Steuerungspfad verwendet werden

(2) Semaphoren, die von Prozessen im Benutzermodus verwendet werden und in POSIX-Semaphoren und SYSTEM

V-Semaphoren unterteilt sind .

POSIX-Semaphore werden in benannte Semaphore und unbenannte Semaphore unterteilt.

Ein benanntes Semaphor, dessen Wert in einer Datei gespeichert wird, sodass es für Threads und die Synchronisierung zwischen Prozessen verwendet werden kann. Unbenannter

Semaphor, dessen Wert im Speicher gespeichert ist.

Kernel-Semaphore

Aufbau eines Kernel-Semaphors

Ein Kernel-Semaphor ähnelt einem Spin-Lock dahingehend, dass es bei geschlossenem Lock nicht zulässt, dass der Kernel-Steuerungspfad fortgesetzt wird. Allerdings

Wenn der Kernel-Steuerungspfad versucht, die durch die Kernel-Semaphorsperre geschützte ausgelastete Ressource abzurufen, wird der entsprechende Prozess angehalten. Erst wenn die Ressource freigegeben wird, wird der Prozess wieder lauffähig.

Nur Funktionen, die schlafen können, können Kernel-Semaphoren erhalten; weder Interrupt-Handler noch aufschiebbare Funktionen können Kernel-Semaphoren verwenden.

Das Kernel-Semaphor ist ein Objekt vom Typ Struktur-Semaphor. In der obigen Routine

#include <pthread.h>
#include <semaphore.h>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int number; // 被保护的全局变量
sem_t sem_id;
void* thread_one_fun(void *arg)
{
sem_wait(&sem_id);
printf("thread_one have the semaphore\n");
number++;
printf("number = %d\n",number);
sem_post(&sem_id);
}
void* thread_two_fun(void *arg)
{
sem_wait(&sem_id);
printf("thread_two have the semaphore \n");
number--;
printf("number = %d\n",number);
sem_post(&sem_id);
}
int main(int argc,char *argv[])
{
number = 1;
pthread_t id1, id2;
sem_init(&sem_id, 0, 1);
pthread_create(&id1,NULL,thread_one_fun, NULL);
pthread_create(&id2,NULL,thread_two_fun, NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
printf("main,,,\n");
return 0;
}

ist es zufällig, welcher Thread zuerst für die Semaphor-Ressource gilt. Wenn Sie eine bestimmte Reihenfolge wünschen, können Sie 2 Semaphore verwenden, um diese zu erreichen. In der folgenden Routine wird beispielsweise die Ausführung von Thread 1 zuerst beendet, und dann wird die Ausführung von Thread 2 bis zum Ende fortgesetzt.

int number; // 被保护的全局变量
sem_t sem_id1, sem_id2;
void* thread_one_fun(void *arg)
{
sem_wait(&sem_id1);
printf(“thread_one have the semaphore\n”);
number++;
printf(“number = %d\n”,number);
sem_post(&sem_id2);
}
void* thread_two_fun(void *arg)
{
sem_wait(&sem_id2);
printf(“thread_two have the semaphore \n”);
number–;
printf(“number = %d\n”,number);
sem_post(&sem_id1);
}
int main(int argc,char *argv[])
{
number = 1;
pthread_t id1, id2;
sem_init(&sem_id1, 0, 1); // 空闲的
sem_init(&sem_id2, 0, 0); // 忙的
pthread_create(&id1,NULL,thread_one_fun, NULL);
pthread_create(&id2,NULL,thread_two_fun, NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
printf(“main,,,\n”);
return 0;
}

(b) Synchronisation unbenannter Semaphoren zwischen verwandten Prozessen

Man spricht von verwandten Prozessen, weil es in diesem Programm zwei Prozesse gibt, von denen einer ein untergeordneter Prozess des anderen ist (generiert von

fork

) .

Ursprünglich erbt der untergeordnete Prozess nur die Codekopie des übergeordneten Prozesses.

Bei der Initialisierung von Mutex bezieht sich pshared = 1 jedoch auf

Dieser Mutex befindet sich im gemeinsam genutzten Speicherbereich, sodass Mutex zu diesem Zeitpunkt zu einer Variablen wird, die von den übergeordneten und untergeordneten Prozessen gemeinsam genutzt wird. An diesem Punkt kann Mutex verwendet werden, um verwandte Prozesse zu synchronisieren.

#include <semaphore.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(int argc, char **argv)
{
int fd, i,count=0,nloop=10,zero=0,*ptr;
sem_t mutex;
//open a file and map it into memory
fd = open("log.txt",O_RDWR|O_CREAT,S_IRWXU);
write(fd,&zero,sizeof(int));
ptr = mmap( NULL,sizeof(int),PROT_READ |
PROT_WRITE,MAP_SHARED,fd,0 );
close(fd);
/* create, initialize semaphore */
if( sem_init(&mutex,1,1) < 0) //
{
perror("semaphore initilization");
exit(0);
}
if (fork() == 0)
{ /* child process*/
for (i = 0; i < nloop; i++)
{
sem_wait(&mutex);
printf("child: %d\n", (*ptr)++);
sem_post(&mutex);
}
exit(0);
}
/* back to parent process */
for (i = 0; i < nloop; i++)
{
sem_wait(&mutex);
printf("parent: %d\n", (*ptr)++);
sem_post(&mutex);
}
exit(0);
}

Das Merkmal eines benannten Semaphors besteht darin, den Wert des Semaphors in einer Datei zu speichern.

Dies bedeutet, dass es ein sehr breites Anwendungsspektrum hat: Es kann für Threads, verwandte Prozesse und sogar nicht verwandte

Prozesse verwendet werden. (a) Der Grund, warum ein benannter Semaphor von Prozessen gemeinsam genutzt werden kann

Da der Wert eines benannten Semaphors in einer Datei gespeichert ist, erbt der untergeordnete Prozess für den zugehörigen Prozess den Dateideskriptor des übergeordneten Prozesses. Dann ist die Datei, auf die der vom untergeordneten Prozess geerbte Dateideskriptor zeigt, dieselbe wie der übergeordnete Prozess. Natürlich wird der in der Datei gespeicherte benannte Semaphorwert gemeinsam genutzt.

(b) Beschreibung der Funktionen im Zusammenhang mit benannten Semaphoren

Wenn das benannte Semaphor verwendet wird, teilt es die Funktionen sem_wait und sem_post mit dem unbenannten Semaphor.

Der Unterschied besteht darin, dass das benannte Semaphor sem_open anstelle von sem_init verwendet. Außerdem muss das benannte Semaphor am Ende wie eine Datei geschlossen werden

.

(1) Öffnen Sie ein vorhandenes benanntes Semaphor oder erstellen und initialisieren Sie ein benanntes Semaphor. Ein einziger Aufruf schließt die Erstellung, Initialisierung und Berechtigungseinstellung des Semaphors ab.

sem_t *sem_open(const char *name, int oflag, mode_t mode, int value);

oflag hat zwei Werte: O_CREAT oder O_CREAT|EXCL;

mode_t steuert die neue Zugriffsberechtigungen des Semaphors;

Wert gibt den Initialisierungswert des Semaphors an.

Hinweis:

Der Name hier kann nicht im Format /tmp/aaa.sem geschrieben werden, da sem unter Linux

im Verzeichnis /dev/shm erstellt wird. Sie können den Namen als „/mysem“ oder „mysem“ schreiben, und die erstellten Dateien lauten „/dev/shm/sem.mysem“. Geben Sie nicht den Pfad an. Schreiben Sie außerdem niemals „/tmp/mysem“ oder ähnliches.

Wenn oflag = O_CREAT und das durch den Namen angegebene Semaphor nicht existiert, wird eines erstellt und die folgenden

Modus- und Wertparameter müssen gültig sein. Wenn das durch den Namen angegebene Semaphor bereits vorhanden ist, öffnen Sie das Semaphor direkt und ignorieren Sie die Parameter „Modus“ und „Wert“.

Wenn oflag = O_CREAT|O_EXCL und das durch den Namen angegebene Semaphor bereits existiert, gibt die Funktion direkt

error zurück.

(2) Sobald Sie Semaphore verwenden, ist es wichtig, diese zu zerstören.

在做这个之前，要确定所有对这个有名信号量的引用都已经通过sem_close（）函数

关闭了，然后只需在退出或是退出处理函数中调用sem_unlink()去删除系统中的信号量，

注意如果有任何的处理器或是线程引用这个信号量，sem_unlink()函数不会起到任何的作

用。

也就是说，必须是最后一个使用该信号量的进程来执行sem_unlick才有效。因为每个

信号灯有一个引用计数器记录当前的打开次数，sem_unlink必须等待这个数为0时才能把

name所指的信号灯从文件系统中删除。也就是要等待最后一个sem_close发生。

（c）有名信号量在无相关进程间的同步

前面已经说过，有名信号量是位于共享内存区的，那么它要保护的资源也必须是位于

共享内存区，只有这样才能被无相关的进程所共享。

在下面这个例子中，服务进程和客户进程都使用shmget和shmat来获取得一块共享内

存资源。然后利用有名信号量来对这块共享内存资源进行互斥保护。

File1: server.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define SHMSZ 27
char SEM_NAME[]= "vik";
int main()
{
char ch;
int shmid;
key_t key;
char *shm,*s;
sem_t *mutex;
//name the shared memory segment
key = 1000;
//create & initialize semaphore
mutex = sem_open(SEM_NAME,O_CREAT,0644,1);
if(mutex == SEM_FAILED)
{
perror("unable to create semaphore");
sem_unlink(SEM_NAME);
exit(-1);
}
//create the shared memory segment with this key
shmid = shmget(key,SHMSZ,IPC_CREAT|0666);
if(shmid<0)
{
perror("failure in shmget");
exit(-1);
}
//attach this segment to virtual memory
shm = shmat(shmid,NULL,0);
//start writing into memory
s = shm;
for(ch=&#39;A&#39;;ch<=&#39;Z&#39;;ch++)
{
sem_wait(mutex);
*s++ = ch;
sem_post(mutex);
}
//the below loop could be replaced by binary semaphore
while(*shm != &#39;*&#39;)
{
sleep(1);
}
sem_close(mutex);
sem_unlink(SEM_NAME);
shmctl(shmid, IPC_RMID, 0);
exit(0);
}
<u>File 2: client.c</u>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define SHMSZ 27
char SEM_NAME[]= "vik";
int main()
{
char ch;
int shmid;
key_t key;
char *shm,*s;
sem_t *mutex;
//name the shared memory segment
key = 1000;
//create & initialize existing semaphore
mutex = sem_open(SEM_NAME,0,0644,0);
if(mutex == SEM_FAILED)
{
perror("reader:unable to execute semaphore");
sem_close(mutex);
exit(-1);
}
//create the shared memory segment with this key
shmid = shmget(key,SHMSZ,0666);
if(shmid<0)
{
perror("reader:failure in shmget");
exit(-1);
}
//attach this segment to virtual memory
shm = shmat(shmid,NULL,0);
//start reading
s = shm;
for(s=shm;*s!=NULL;s++)
{
sem_wait(mutex);
putchar(*s);
sem_post(mutex);
}
//once done signal exiting of reader:This can be replaced by
another semaphore
*shm = &#39;*&#39;;
sem_close(mutex);
shmctl(shmid, IPC_RMID, 0);
exit(0);
}

SYSTEM V信号量

这是信号量值的集合，而不是单个信号量。相关的信号量操作函数由

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
static int nsems;
static int semflg;
static int semid;
int errno=0;
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
}arg;
int main()
{
struct sembuf sops[2]; //要用到两个信号量，所以要定义两个操作数组
int rslt;
unsigned short argarray[80];
arg.array = argarray;
semid = semget(IPC_PRIVATE, 2, 0666);
if(semid < 0 )
{
printf("semget failed. errno: %d\n", errno);
exit(0);
}
//获取0th信号量的原始值
rslt = semctl(semid, 0, GETVAL);
printf("val = %d\n",rslt);
//初始化0th信号量，然后再读取，检查初始化有没有成功
arg.val = 1; // 同一时间只允许一个占有者
semctl(semid, 0, SETVAL, arg);
rslt = semctl(semid, 0, GETVAL);
printf("val = %d\n",rslt);
sops[0].sem_num = 0;
sops[0].sem_op = -1;
sops[0].sem_flg = 0;
sops[1].sem_num = 1;
sops[1].sem_op = 1;
sops[1].sem_flg = 0;
rslt=semop(semid, sops, 1); //申请0th信号量，尝试锁定
if (rslt < 0 )
{
printf("semop failed. errno: %d\n", errno);
exit(0);
}
//可以在这里对资源进行锁定
sops[0].sem_op = 1;
semop(semid, sops, 1); //释放0th信号量
rslt = semctl(semid, 0, GETVAL);
printf("val = %d\n",rslt);
rslt=semctl(semid, 0, GETALL, arg);
if (rslt < 0)
{
printf("semctl failed. errno: %d\n", errno);
exit(0);
}
printf("val1:%d val2: %d\n",(unsigned int)argarray[0],(unsigned int)argarray[1]);
if(semctl(semid, 1, IPC_RMID) == -1)
{
Perror(“semctl failure while clearing reason”);
}
return(0);
}

推荐学习： swoole教程

Das obige ist der detaillierte Inhalt vonWas ist die Verwendung von Semaphor in Swoole?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!