En muchos casos, un programa necesita perder tiempo, esto es, esperar unos segundos sin hacer nada, o similar. Un sistema muy usado en programas DOS consiste en un bucle de espera, que tarde justo el tiempo que nos interesa. Sin embargo, este sistema es bastante imperfecto, pues si el programa funciona bien en un ordenador concreto, en otro que sea más rápido o más lento no lo hará. La segunda solución que 'encontraron' los programadores fue usar el timer del ordenador, un integrado que puede ser programado para que provoque interrupciones cada n milisegundos. Como ese chip es el mismo en todos los PCs, sin importar su velocidad, permite que los programas funcionen igual en todos.
En OS/2, sin embargo, no se puede permitir esto, pues puede haber múltiples programas que necesiten el temporizador a la vez. Para solucionarlo, surgen los temporizadores.
Antes de nada, conviene señalar que los temporizadores de OS/2 (así como los de cualquier otro S.O. multitarea) no son todo lo precisos que sería deseable. Esto se debe en primer lugar a que, aunque especifiquemos la temporización al milisegundo, será redondeado al ciclo superior del conmutador de tareas (en OS/2, normalmente, son 32 milisegundos). Por otro lado, OS/2 es un Sistema Operativo multitarea por prioridades, por lo que puede ocurrir que en el momento en que expire un temporizador, haya otro proceso de más prioridad esperando a ejecutarse, en cuyo caso se producirá otro retardo. Sin embargo, existen maneras de minimizar estos efectos, y OS/2 las ofrece.
Una primera clasificación de los temporizadores los divide en síncronos y asíncronos. Un temporizador síncrono se activa y no devuelve el control al thread hasta que este termine. Es el caso más básico: si queremos hacer una pausa de 1 segundo, llamamos a la función DosSleep, y el thread correspondiente se dormirá durante el tiempo fijado.
Sin embargo, puede no interesarnos este sistema, sino que durante ese intervalo podemos necesitar hacer alguna operación y luego dormirnos hasta terminarlo. Por ejemplo, queremos un programa que, una vez por segundo, imprima un caracter en pantalla. Una primera idea sería imprimir un caracter, dormir un segundo, imprimir otro, dormir un segundo, etc. Sin embargo, el hecho de imprimir el caracter consume algo de tiempo, luego estamos gastando algo más. Por otro lado, ese tiempo es variable, en función de la velocidad del ordenador y de la tarjeta gráfica. Por eso existen los temporizadores asíncronos.
Un temporizador asíncrono necesita de un semáforo, pues lo necesita para notificar al thread que se ha acabado el intervalo de tiempo. La idea es la siguiente: el thread inicializa el temporizador, el cual activa el semáforo y empieza a contar, pero devuelve el control al programa. Este sigue trabajando (imprimiría el caracter o lo que tuviese que hacer), y cuando termine, espera a que el semáforo se active (post) (que será hecho por el temporizador cuando expire). De este modo, no importa cuanto dure el proceso que haga el thread: siempre esperará un segundo (o el tiempo elegido, redondeado al ciclo del conmutador de tareas).
Como decíamos, la temporización no es precisa por estar redondeada a 32 milisegundos. Esto puede ser problemático cuando se encadenan temporizaciones. En el ejemplo anterior, si programamos un temporizador para cada segundo, la ejecución de la instrucción cada vez ya lleva algo de tiempo, y además, los redondeos se van sumando cada vez más, de modo que podemos llegar a tener un desfase entre el ritmo que debería llevar y el que lleva realmente. Para eso, existe otro temporizador asíncrono que borra un semáforo no una vez, sino constantemente, a cada paso del ciclo. Es este el que deberímos usar en nuestro ejemplo. Este temporizador, como es cíclico (está contando constantemente intervalos del tiempo que queramos, y no una sola vez como hacía el primero) puede tener en cuenta el redondeo del conmutador de tareas, y minimizar su efecto.
Por último, tenemos las funciones de fecha y hora, las cuales permiten obtener y cambiar estos datos. Un detalle importante es que solo existe una fecha y una hora. Esto significa que si un programa los cambia, lo hace para todos, no solo para él mismo.
