multithreading - set_start_method - python pool process

¿Es posible usar mutex en casos de multiprocesamiento en Linux/UNIX?

Question

Esta es una pregunta de entrevista.

¿Es posible usar mutex en casos de multiprocesamiento en Linux / UNIX?

Mi idea: No, diferentes procesos tienen espacio de memoria separado.

Mutex solo se utiliza para multiproceso.

El semáforo se usa para multiprocesamiento para hacer la sincronización.

derecho ?

Cualquier comentario es bienvenido.

Gracias

Answer 1

Es bastante posible utilizar un mutex de proceso compartido .

De hecho, las aplicaciones modernas prefieren usar un proceso de exclusión mutua junto con una variable de condición de proceso compartido en lugar de un semáforo porque esta última es menos flexible.

Recuerdo que usé Red Hat Linux en 2004 y en ese momento admitía procesos de exclusión mutua y variables de condición.

Answer 2

Estaba buscando una exclusión mutua con nombre para poder garantizar la exclusión mutua durante la vida útil de un proceso (asegurándome de que solo se ejecute un proceso por algún conjunto de propiedades). No encontré uno (parece que podría no haberlo visto lo suficiente) y, por lo tanto, implementé mi propio pseudo nombre mutex en Linux utilizando un socket de dominio UNIX abstracto. Sólo un enlace único () a ese socket tendrá éxito. La otra cosa buena es que el sistema operativo limpiará el socket de dominio UNIX abstracto si el proceso muere y, por lo tanto, no limpia el socket en sí. Desafortunadamente, no estoy seguro de ninguna manera para que usted "espere" en este pseudo mutex para que esté disponible.

Un socket de dominio UNIX abstracto es un socket de dominio UNIX cuyo nombre comienza con un byte nulo. Sin embargo, tenga en cuenta que creo que todo el búfer se usa como nombre y, por lo tanto, desea asegurarse de que no solo inscriba una cadena parcial, o si lo hace, asegúrese de llenar primero todo el búfer con algún carácter. .

Todos menos el primer bind () fallará con un error de EADDRINUSE.

// Create an abstract socket to use as a mutex.
int err;
int mutex_sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (mutex_sock == -1)
{
err = errno;
printf("main, failed creating mutex socket: %s/n",
get_error_string(errno, error_string, sizeof(error_string)));
log_event(LOG_LEVEL_ERROR, "main, failed creating mutex socket: "
"%s", get_error_string(errno, error_string,
sizeof(error_string)));
errno = err;
goto done;
}
// Bind to abstract socket. We use this as a sort of named mutex.
struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path + 1, socket_name, sizeof(addr.sun_path) - 2);
result = bind(mutex_sock, (struct sockaddr*) &addr, sizeof(addr));
if (result == -1)
{
err = errno;
if (errno == EADDRINUSE)
{
printf("main, failed bind to mutex socket: %s. "
"Another instance must be running./n",
get_error_string(errno,
error_string, sizeof(error_string)));
log_event(LOG_LEVEL_ERROR, "main, failed bind to mutex socket: "
"%s. "
"Another instance must be running.",
get_error_string(errno,
error_string, sizeof(error_string)));
}
else
{
printf("main, failed bind to mutex socket: %s/n",
get_error_string(errno, error_string,
sizeof(error_string)));
log_event(LOG_LEVEL_ERROR, "main, failed bind to mutex socket: %s",
get_error_string(errno, error_string,
sizeof(error_string)));
}
errno = err;
goto done;
}

Gracias nick

Answer 3

No exactamente. Los subprocesos POSIX tienen un concepto de un atributo de proceso compartido que se puede usar para crear mutexes que pueden ser operados por múltiples procesos.

Puede colocar dicho mutex en la memoria compartida para que todos los procesos puedan acceder a ella.

Si LINUX implementa esto. No estoy seguro, nunca tuve la necesidad de usarlo, ya que parece innecesariamente complejo.

Para un resumen útil de atributos, vea mi respuesta a esta pregunta .

Answer 4

Sí, en general en Linux solo tenemos mutex sin nombre debido a que no pueden operar entre procesos. Necesitamos un semáforo para superar eso.

En Windows, tienen un concepto de exclusión mutua con nombre que nos permite utilizar la exclusión mutua en todos los procesos.

Answer 5

 Mutual exclusion locks (mutexes) prevent multiple threads
from simultaneously executing critical sections of code that
access shared data (that is, mutexes are used to serialize
the execution of threads). All mutexes must be global. A
successful call for a mutex lock by way of mutex_lock()
will cause another thread that is also trying to lock the
same mutex to block until the owner thread unlocks it by way
of mutex_unlock(). Threads within the same process or
within other processes can share mutexes.
Mutexes can synchronize threads within the **same process** or
in ***other processes***. Mutexes can be used to synchronize
threads between processes if the mutexes are allocated in
writable memory and shared among the cooperating processes
(see mmap(2)), and have been initialized for this task.

Initialize Mutexes puede ser intra-proceso o inter-proceso, dependiendo del argumento pasado implícitamente o explícitamente a la inicialización de ese mutex. Un mutex asignado estáticamente no necesita ser explícitamente inicializado; de forma predeterminada, una exclusión mutua asignada estáticamente se inicializa con todos los ceros y su alcance se establece dentro del proceso de llamada.

 For inter-process synchronization, a mutex needs to be allo-
cated in memory shared between these processes. Since the
memory for such a mutex must be allocated dynamically, the
mutex needs to be explicitly initialized using mutex_init().