En los primeros días de FORTRAN y BASIC, esencialmente todos los programas fueron escritos con declaraciones GOTO. El resultado fue un código de espagueti y la solución fue una programación estructurada.
Del mismo modo, los punteros pueden tener características difíciles de controlar en nuestros programas. C ++ comenzó con muchos punteros, pero se recomienda el uso de referencias. Las bibliotecas como STL pueden reducir parte de nuestra dependencia. También hay modismos para crear punteros inteligentes que tienen mejores características, y algunas versiones de C ++ permiten referencias y código administrado.
Las prácticas de programación como la herencia y el polimorfismo utilizan muchos punteros detrás de escena (al igual que, mientras que la programación estructurada genera código lleno de instrucciones de ramificación). Los lenguajes como Java eliminan los punteros y usan la recolección de elementos no utilizados para administrar datos asignados dinámicamente en lugar de depender de los programadores para que coincidan con todas sus declaraciones nuevas y eliminadas.
En mi lectura, he visto ejemplos de programación multiproceso y multiproceso que no parecen utilizar semáforos. ¿Utilizan lo mismo con nombres diferentes o tienen nuevas formas de estructurar la protección de los recursos contra el uso concurrente?
Por ejemplo, un ejemplo específico de un sistema para programación multiproceso con procesadores multinúcleo es OpenMP. Representa una región crítica de la siguiente manera, sin el uso de semáforos, que parecen no estar incluidos en el entorno.
th_id = omp_get_thread_num();
#pragma omp critical
{
cout << "Hello World from thread " << th_id << '\n';
}
Este ejemplo es un extracto de: http://en.wikipedia.org/wiki/OpenMP
Alternativamente, una protección similar de los hilos entre sí utilizando semáforos con las funciones wait () y signal () podría verse así:
wait(sem);
th_id = get_thread_num();
cout << "Hello World from thread " << th_id << '\n';
signal(sem);
En este ejemplo, las cosas son bastante simples, y una simple revisión es suficiente para mostrar que las llamadas wait () y signal () coinciden e incluso con mucha concurrencia, se proporciona seguridad de subprocesos. Pero otros algoritmos son más complicados y usan múltiples semáforos (tanto binarios como de conteo) distribuidos en múltiples funciones con condiciones complejas que pueden ser llamadas por muchos hilos. Las consecuencias de crear un punto muerto o no hacer que las cosas sean seguras pueden ser difíciles de manejar.
¿Estos sistemas como OpenMP eliminan los problemas con los semáforos?
¿Mueven el problema a otro lugar?
¿Cómo transformo mi semáforo favorito usando un algoritmo para no usar más semáforos?