Publi

  • Singletons en C++. Intentando que sean seguros en hilos (thread safety) II

    22 abril, 2014 Author: Gaspar Fernández
    13 Comments

    Singleton thread-safeAyer hablábamos de la creación de un sigleton y de que nuestro ejemplo no era «thread safe», vamos, que en un entorno con varios hilos de ejecución cabe la posibilidad de que el comportamiento esperado no siempre se cumpla.

    Ahí encontrábamos diferencias entre C++ (<11) y C++11 ya que esta última revisión incluye tratamiento de threads y algunas cosas más que trataremos aquí.

    Lo primero que podemos pensar, es que al traernos la instancia de nuestro singleton se crea una sección crítica, la cuál podemos regular con un mutex, provocando que siempre que vayamos a obtener una instancia de nuestro objeto pasemos por el semáforo, y aunque dos threads quieran pelearse por ver quién crea antes el recurso, sólo uno lo conseguirá finalmente.… Leer artículo completo

  • Singletons en C++ y alguna nota sobre thread safety (I)

    21 abril, 2014 Author: Gaspar Fernández
    25 Comments

    Antes de nada, comentar que he dividido este post en dos porque vi que se estaba alargando demasiado y se lanzarán uno al día, pondré aquí enlaces a todos los posts.

    Muchas veces cuando estamos programando tenemos la necesidad de crear un objeto de una clase determinada, pero éste objeto deberá ser creado una sola vez en nuestra aplicación y debemos evitar a toda costa que pueda ser creado más veces.… Leer artículo completo

  • Flags en un enum en C

    29 marzo, 2014 Author: Gaspar Fernández
    3 Comments


    Las flags, son opciones binarias que acompañan un dato o un sistema y valen para informar o definir su comportamiento o su estado entre otras cosas.

    En muchos casos, utilizaremos flags para ver el resultado de una operación, imaginémonos que estamos pasando una serie de tests a un dato de texto:

    1. El dato no está vacío
    2. El dato tiene más de 3 letras
    3. El dato tiene menos de 20 letras
    4. El dato tiene caracteres no numéricos
    5. El dato tiene caracteres no números/letras
    6. El dato tiene caracteres de control
    7. El dato tiene caracteres no válidos
    8. El dato tiene formato de fecha
    9. El dato tiene formato de hora
    10. El dato tiene formato de teléfono
    11. El dato tiene formato de coordenadas

    Bueno, así puedo poner muchas condiciones, lo importante es la forma de almacenarlo.… Leer artículo completo

  • Creando un mutex con semáforos entre procesos hijos en C [fork()]

    12 marzo, 2014 Author: Gaspar Fernández
    3 Comments

    Hemos estado viendo cómo compartir variables entre procesos hijos, y dejamos un poco en el tintero la implementación de mutex en ese caso, esta vez, para implementar el mutex vamos a utilizar semáforos. Estos semáforos también tienen que ser variables compartidas para funcionar correctamente.

    Los semáforos tendrá un funcionamiento peculiar. En principio, pensemos en ellos con los valores 1 y 0. Por tanto, si el semáforo vale 1, el semáforo está abierto y lo haremos 0, pero si vale 0, nos esperaremos hasta que valga 1 (al contrario que un while (semaforo==0); utilizando semáforos, será el sistema operativo el que active nuestro proceso cuando el semáforo vale 1 por lo que podemos utilizar los recursos del sistema para otra cosa mientras).… Leer artículo completo

  • Variables compartidas entre procesos hijos en C [fork()]

    26 febrero, 2014 Author: Gaspar Fernández
    5 Comments

    Otra forma de enfrentarse con la concurrencia, en el maravilloso mundo de hacer varias cosas al mismo tiempo, es utilizar procesos hijos con fork(). La principal diferencia con respecto a los threads es que éstos son procesos completos, es decir, el sistema operativo les ha dado una zona de memoria de código, otra de datos, y otra de pila, a diferencia de los threads que compartían código y datos, sólo tenían la pila diferente.… Leer artículo completo

  • ListView con búsqueda rápida en GTKMM

    19 febrero, 2014 Author: Gaspar Fernández
    7 Comments

    Es muy útil cuando listamos elementos en una aplicación proporcionar al usuario una opción de búsqueda rápida. Hacemos la aplicación más amigable con poco esfuerzo extra por nuestra parte.

    El ejemplo que traigo es muy parecido al ejemplo de ListStore, aunque añado la posibilidad de filtrar la lista con el texto introducido en un widget Entry.

    La clave está en crear una columna más en el modelo de datos (c_visible) que determinará si el elemento es visible o no en la lista, y en lugar de hacer que nuestro TreeView siga el modelo por defecto, haremos que siga un modelo filtrado.… Leer artículo completo

  • Concurrencia, cuando varios hilos (threads) pelean por el acceso a un recurso [ejemplos en C]

    7 febrero, 2014 Author: Gaspar Fernández
    6 Comments

    Si estamos desarrollando nuestra aplicación multi-hilo y además compartimos información entre el hilo principal y el secundario, o entre varios hilos tenemos que tener en cuenta el tipo de acceso a las variables compartidas.
    Por ejemplo, si sólo vamos a permitir que un hilo escriba, y todos los demás lean, casi no vamos a tener problemas, pero si cualquier thread de nuestra aplicación va a poder escribir en cualquier momento, tenemos que tener cuidado con cómo lo hacemos, ya que si varios hilos intentan escribir un recurso, sólo la última escritura será efectiva, y si el valor antiguo de la variable es crítico, en muchos casos no se tendrá en cuenta.… Leer artículo completo

  • Concurrencia, POSIX threads y variables compartidas en C

    17 enero, 2014 Author: Gaspar Fernández
    2 Comments


    Hace poco veíamos cómo empezar a hacer nuestros primeros programas multi-thread utilizando POSIX threads. Aunque pronto surge una nueva necesidad: compartir datos entre el proceso principal y el thread que se ha creado, al menos para decirle qué queremos que haga. Para eso podemos utilizar el último argumento de la función pthread_create(), el cuál es un puntero a void, por lo que podemos pasar cualquier tipo de variable. Por ejemplo un número:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>

    void *newtask(void *_number)
    {
      int number = *(int*)_number;
      printf("The number I was asked for: %d\n", number);
      pthread_exit(NULL);
    }

    int main (int argc, char *argv[])
    {
       pthread_t thread;
       int rc;
       int i;
       int number = 99;

       printf ("Main process just started.
    … Leer artículo completo

  • Cliente TCP no bloqueante en C, en el que podemos enviar y recibir en cualquier momento

    13 enero, 2014 Author: Gaspar Fernández
    1 Comment

    Hace tiempo veíamos un artículo de un servidor que fuera capaz de aceptar múltiples conexiones, ahora, toca le toca el turno a la implementación del cliente.

    En principio, vamos a implementar un cliente sencillo, en el que conectaremos a un servidor y nos permitirá enviar texto que escribamos por teclado. No podremos recibir nada del servidor, pero nos servirá como primera aproximación:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <netdb.h>
    #include <arpa/inet.h>
    #include <errno.h>
    #include <unistd.h>

    #define MENS_MAX_LEN 500

    void usage()
    {
      fprintf (stderr, "Wrong arguments.
    … Leer artículo completo

  • Pinceladas de concurrencia y Hello world usando pthreads

    1 enero, 2014 Author: Gaspar Fernández
    4 Comments


    En la actualidad, es muy común ver CPUs es dual-core o quad-core (por lo menos), aunque también sigue habiendo sistemas con un sólo núcleo.

    Antes de nada, quiero decir que en este post sólo quiero dar algunas pinceladas, y un poco de código como introducción a este «mundo», por lo que las explicaciones serán algo rápidas, me refiero a que estaré simplificando mucho, en el fondo, todo es un poco más complicado… pero al menos daré datos suficientes para poder profundizar más en el tema.… Leer artículo completo

Página anterior Siguiente página