Archivo

Entradas Etiquetadas ‘Threads’

Multi-Threading for TBitmap, TCanvas, and TContext3D

Viernes, 7 de Abril de 2017 8 comentarios
Share Button

Mucho se ha hablado de las características de Tokyo en cuanto al soporte de nuevas plataformas. Está claro que la irrupción de Linux entre las plataformas destino de nuestras aplicaciones, es el gran atractivo de esta nueva versión. Otros compañeros de la comunidad han hablado del tema y han publicado vídeos al respecto.

En mi caso voy a hablar de otra de las novedades de la versión Tokyo. Se trata del soporte de multithread para las clases TBitmap, TCanvas y TContext3D en Firemonkey para poder trabajar con un único elemento desde diferentes threads.

Tal y como se explica en el enlace de la wiki, internamente las clases realizan la sincronización de forma automátca, así que aunque no ganemos en rendimiento, si podemos ganar en organización y en claridad a la hora de escribir nuestro código y clases. Imaginad que tenemos que dibujar diferentes objetos o elementos en un TCanvas. Ahora podamos organizar el trabajo en diferentes clases (Threads) que se encarguen de dibujar cada uno de ellos. De otra forma tendríamos que tener un único código o clase donde se dibujaran todos ellos (por lo tanto menos estructurado y organizado).

Leer más…

Share Button

Obtener información de una canción

Martes, 13 de Mayo de 2014 2 comentarios
Share Button

images (2)El tema de esta entrada ha surgido a partir de la necesidad de obtener esta información de una canción, para un programa  que en breve os presentaré en otra entrada del blog.
Esta parte no tiene que ver directamente con el tema de esa entrada, pero sí me ha parecido interesante y tal vez útil para otras personas, así que me he decidido a publicar estas líneas al respecto, ya que en la otra no tiene cabida.

El problema es sencillo; A partir de los datos básicos de un tema musical (título y/o artista) necesito obtener algo de información de esa canción. En mi caso me interesaba el título del álbum y una caratula (aunque se puede obtener más).

Hay varios servicios en Internet que os ofrecen la posibilidad de acceder a esta información.

http://www.lastfm.es/api

http://www.freecovers.net/api/

https://www.apple.com/itunes/affiliates/resources/documentation/itunes-store-web-service-search-api.html

images (3) En esta ocasión me he decantado por iTunes, por la facilidad de uso y porque no hace falta registrarse. Hay algunos otros cuya utilización es gratuita, pero requieren un registro y el uso de una APIKey. En este caso, por simple sencillez, me he decantado por este. Además, ya me ofrece (con creces) los datos que para este ejemplo estaba buscando.

En esta página podeís acceder a la información de la API para realizar búsquedas en iTunes.

Como podéis ver es bastante sencilla de utilizar.

Leer más…

Share Button
Categories: Aplicación, Delphi, Threads Tags: , , ,

Utilizar ADO con Threads

Viernes, 14 de Enero de 2011 1 comentario
Share Button

Los threads (o hilos de ejecución), en general, se ven como un tema peliaudo; Son unas “cosas” que están ahí, son buenas (eso dice todo el mundo), pero cuando más se tarde en tener que tacarlos, mejor…  ;-D

Recuerdo que cuando empecé en esto de la programación, los threads o la “programación con múltiples hilos de ejecución” sonaba algo así como “muy difícil”. A medida que va pasando el tiempo, uno se da cuenta que que no es así, y cuando has hecho unos cuantos ejemplos te das cuenta de la potencia que aportan y de que realmente sólo hay que tener algunas “precauciones” a la hora de utilizarlos.

En este misma página podéis encontrar algunos ejemplos (“ping usando threads”, Ejemplo visual y Ejemplo visual ampliado) de programación de hilos de ejecución con Delphi. Ejemplos bastantes sencillos y bastante inútiles, porqué no decirlo, exceptuando la utilidad de aprender cómo funcionan y poder ver un código simple de utilización.

La idea de esta entrada es ir un poco más allá. A veces nos encontramos en una aplicación, con determinadas consultas que tardan mucho tiempo y que no es imprescindible esperar a su finalización para poder continuar con la ejecución normal del programa. Las más comunes serías típicas consultas de Listados, estadísticas o determinadas operaciones que podríamos hacer en 2º plano. Esas consultas serían las candidatas ideales para poder lanzarlas en un Thread independiente del hilo principal del programa.

Para los ejemplos voy a utilizar los componentes ADO y accederemos a la Base de Datos dbdemos.mdb que viene con Delphi.

Para trabajar con ADO utilizando threads, o para lanzar consultas dentro de threads, la única condición es que la conexión (TADOConnection) se cree dentro del mismo thread. Utilizaremos para ello una “cadena de conexión” como propiedad del Thread.

La estructura de la clase podría ser algo así:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
TADOSQLThread = class(TThread)
  private
    FADOQ: TADOQuery;
    FSQL: string;
    FTotalTime:string;
  public
    constructor Create(CreateSuspended:Boolean; AConnString:String;
                       ASQL:string);
    destructor Destroy; override;
    procedure Execute(); override;
    property SQL:string read FSQL write FSQL;
    property ADOQ:TADOQuery read FADOQ write FADOQ;
    property TotalTime:string read FTotalTime;
end;

Para lanzar desde una aplicación una consulta utilizando nuestra clase TADOSQLThread , debería bastar con asignar la conexión, la cadena SQL, lanzar nuestro thread y esperar a que acabe. El código podría ser este:

0
1
2
3
4
5
  //crear el Thread; Pasamos los parámetros de conexión y SQL
  th := TADOSQLThread.Create(True, AConnection, ASQL);
  // Evento finalizacion; Al finalizar el control me llegará hasta este evento.
  th.OnTerminate := TerminateThread;
  // Ejecutarlo (ponerlo en marcha)
  th.Resume;

El código operativo del thread es sencillo, se encuentra en el método Execute y lo único que hace es ejecutar la consulta; En el constructor cremos la nueva Query (con una nueva conexión) y asignamos la SQL.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
constructor TADOSQLThread.Create(CreateSuspended:Boolean;
           AConnString:String; ASQL:string);
begin
  // Creamos el thread inicialmente suspendido (para asignarle las props.)
  inherited Create(CreateSuspended);
  // No liberar automáticamente
  Self.FreeOnTerminate := False;
  //crea el query
  FADOQ := TAdoquery.Create(nil);
  FADOQ.ConnectionString := AConnString;
  FADOQ.SQL.Add(ASQL);
  Self.FSQL:= ASQL;
end;
 
procedure TADOSQLThread.Execute();
begin
  inherited;
  // Ejecutar la consulta
  Self.FADOQ.Open;
end;

Ahora haría falta probar si en la ejecución de una serie de sentencia SQL con y sin threads se aprecian diferencias visibles. Hay que tener en cuenta que el utilizar o no threads también implica otras cosas.

No todo en este escenario son ventajas, hay que tenerlo en cuenta y entender el funcionamiento para sopesar si en cada caso concreto es beneficioso utilizar threads. Hay 2 grandes inconvenientes que a priori se detectan fácilmente cuando se ejecuta y se prueba un ejemplo como el que vamos a realizar.

Gasto de conexiones: En una ejecución normal, las consultas que se lanzan utilizan todas la misma conexión (ADOConnection); Una premisa que hemos marcado para trabajar con threads, es que cada thread debe funcionar con su conexión propia. Esto implica que en un caso estamos utilizando una única conexión y en el otro X conexiones concurrentes. Esto puede ser un problema en segun qué sistemas.

Sobrecarga de tiempo: El segundo problema (derivado en cierta manera del primero) es la sobrecarga de tiempo que la creación y activación de las nuevas conexiones provoca. Crear, activar (sobre todo este) y liberar las conexiones de cada thread es un tiempo añadido que hay que tener en cuenta.

Estos 2 problemas no se puede solucionar (del todo), pero sí mitigar utilizando un “pool de conexiones“; No es un tema para desarrollar ahora (tal vez más adelante), pero la idea explicada de forma sencilla, es que podemos utilizar un número máximo de conexiones (no tantas como threads). De esta forma, se asigna una conexión libre a un thread cuando la necesita, mientras haya conexiones libres; Cuando ya no quedan libres, el thread debe esperar a que una finalice para que le sea asignada. De esta forma podemos fijar el número máximo de conexiones que se utilizan y además optimizar tiempo, ya que esas conexiones se pueden “reaprovechar” de forma que no exista la necesidad de crear/activar/destruir cada una de ellas.

¿Cuando usar threads y cuando no?

La regla sencilla sería: “Cuanto más grandes y pesadas sean las consultas, más a cuenta sale utilizar threads”.

Si lanzamos 20 consultas que tardan muy poco tiempo, el retraso en crear/activar las conexiones de cada una de ellas puede hacer que el tiempo de preparación sea mayor que el de la propia consulta; En ese caso estaremos “gastando” mas tiempo en “preparar” que en “consultar. Por el contrario si esas 20 consultas tardan 30 segundos cada una, el tiempo de extra de conectar para cada una de ellas puede pasar desapercibido (cuando mayor sea el tiempo de consulta, más eficiente este sistema).

Resultado de las pruebas

En las pruebas he lanzado una serie de consultas de forma secuencial. Hay que notar que el tiempo total (para consultas grandes) es sensiblemente menos cuando utilizamos threads; Pero no sólo hay que tener en cuenta el tiempo total, sino el intervalo en que tenemos acceso al resultado de cada consulta.

De forma secuencial, si la primera consulta tarda 10, la segunda 5 y la tercera 7; El tiempo total es de 22, pero los tiempos de acceso a los resultados son 10, 15 y 22 segundos respectívamente; En cambio si esto se hiciera con threads, aun suponiendo que el tiempo total fuera el mismo, los tiempo de acceso a los resultados serían 10, 5 y 7 segundos.

Select * from CustomerSelect * from Employee
Select * from CountrySelect * from items
Select * from Parts

Select * from VendorsSELECT employee.* FROM employee ORDER BY Salary,
LastName DESC , FirstName DESC , HireDate DESC

SELECT employee.* FROM employee ORDER BY Salary DESC

SELECT customer.*, orders.*, items.*, parts.*, vendors.*,
vendors.State, items.Discount, orders.SaleDate, *
FROM vendors INNER JOIN (parts INNER JOIN ((customer INNER JOIN orders
ON customer.CustNo = orders.CustNo)
INNER JOIN items ON orders.OrderNo = items.OrderNo)
ON parts.PartNo = items.PartNo)
ON vendors.VendorNo = parts.VendorNo
ORDER BY vendors.State, items.Discount DESC , orders.SaleDate

La primera prueba consta de una serie de consultas que tardan muy poco tiempo, con la Base de Datos de Access DBDEMOS.MDB (que se adjunta con Delphi). En este caso se puede ver que los tiempos de las consultas individuales son sensíblemente más bajos sin threads que con threads, debido a que las consultas con threads incluyen el tiempo de conexión. Finalmente aunque los tiempos individuales son mayores (con threads) el tiempo total queda bastante igualado (se compensa la ejecución con threads con la pérdida en las conexiones).

DATOS SIN THREADS.

DATOS CON THREADS

¿Qué pasaría si lanzáramos algunas consultas que tarden más tiempo?

Para el ejemplo he utilizado datos propios conectando a SQL Server, ya que los de la Base de Datos DBDEMOS sólo nos sirven para realizar pequeñas pruebas. Os animo a que cambieis la conexión ADO que viene en el ejemplo y configuréis vuestra propia conexión y vuestras propias consultas para realizar las pruebas.

Para la conexión basta con pulsar el botón que aparece en la parte derecha de la conexión:

Y para las consultas,  basta con tener la precaución de colocar el caracter @ al inicio de cada una de las SQL (sólo cuando empieza la consulta, no en el salto de línea).

En este caso, vemos que los resultados sí cambian sensiblemente; Lo primero que nos llama la atención, es la diferencia de tiempo total de la serie de consultas (con y sin threads); He realizado unas cuantas ejecuciones, alternando primero unas y luegos las otras y los resultados de tiempos son estos; Los primeros son las consultas normales y los segundos con threads:

Sin threads:

·············································
Tiempo total(todo): 01:19:359
Tiempo total(todo): 01:18:516
Tiempo total(todo): 01:04:500
Tiempo total(todo): 01:08:969
Tiempo total(todo): 01:09:718
·············································

Con threads:

·············································
Tiempo total con threads(todo): 01:00:000
Tiempo total con threads(todo): 00:46:800
Tiempo total con threads(todo): 00:45:484
Tiempo total con threads(todo): 00:53:078
·············································

Posteriormente he lanzado, para variar, 4 ejecuciones concurrentes de ejemplo; 2 con threads y 2 sin threads y el resultado ha sido similar (en cuanto a la diferencia):

·············································
Tiempo total(todo): 01:48:984
Tiempo total(todo): 01:50:860
·············································
·············································
Tiempo total con threads(todo): 01:27:593
Tiempo total con threads(todo): 01:32:860
·············································

CONCLUSIÓN: Aunque el ejemplo es bastante sencillo, y la clase que implementa los threads tiene poca “chicha” yo creo que se ven las posibilidades de utilizar esta opción. También debe quedar claro que no es algo para usar “siempre”; Hemos visto que dependiendo del escenario donde se utiliza puede resultar inútil e incluso contraproducente, ya que gasta más recursos que la técnica sin threads. Como ventaja tenemos que la utilización de threads, en general, nos aporta paralelismo y mayor control en la ejecución del programa (ya que evitamos el “bloqueo” en el caso de una consulta muy costosa).

El código fuente del ejemplo, el binario podeís descargarlo desde aquí.

<DESCARGAR CODIGO FUENTE>

Un saludo.

 
Share Button
Categories: Artículos, Delphi, OOP Tags: , ,

PING “threaded” usando ICMP.DLL

Miércoles, 16 de Diciembre de 2009 4 comentarios
Share Button

Hay muchas formas de implementar un PING. Una de ellas es utilizando la librería ICMP.DLL (Internet Control Message Protocol).
Basándome en la Unit Ping.pas que utiliza esta librería extraída de delphi-Central, he creado un ejemplo que la utiliza combinando las llamadas con Threads.

La unit Ping.pas se puede descargar desde la página anterior o desde aquí (raw_ping). El ejemplo crea una clase llamada TPingThread con la siguiente estructura:

0
1
2
3
4
5
6
7
8
9
10
  TPingThread = class(TThread)
  private
    mmResult:TMemo;
  protected
    procedure Execute; override;
    procedure UpdateResult;
  public
    PingResult:TPingResult;
    Ready:Boolean;
    constructor Create(Ping:TPingResult);
  end;

En este caso hemos añadido un TMemo para poder usarlo en la sincronización y mostrar los resultados, aunque no seía necesario (sólo para mostrarlos en este ejemplo), ya que los resultados realmente se alamacenan en la variable PingResult.

El thread utiliza el procedimiento IcmpSendEcho para realiza el Ping.

Se puede descargar el código fuente y los binarios compilados con Delphi 6:
<CODIGO FUENTE>
<BINARIO>

Se puede comparar este con un ejemplo similar realizado sin threads.
<DESCARGAR BINARIO>

Share Button
Categories: Delphi, Ejemplos Tags: , ,

Ejemplo sobre Threads ampliado (v. 2)

Martes, 8 de Enero de 2008 Sin comentarios
Share Button

Se ha ampliado el ejemplo anterior sobre threads, para mostrar cómo se puede configurar el número de threads que se deseen para ejecutar una tarea concreta. Se puede definir un número máximo (por el usuario) y se muestra cómo se van ejecutando threads.
A medida que los primeros van acabando, se lanzan nuevos hasta completar todo el proceso.

Imagen del ejemplo

Download Descargar ejemplo

Share Button
Categories: Difícil, Ejemplos Tags: ,

Ejemplo sobre Threads

Domingo, 6 de Enero de 2008 3 comentarios
Share Button

Este ejemplo es una muestra simple de como crear diferentes Threads y hacerlos funcionar; Es básico pero puede servir como comienzo para aprender el funcionamento. Como crearlos, ponerlos en marcha, pausarlos/reanudarlos y modificar su prioridad.
Hay diferentes tipos, aunque al final la estructura de todos ellos es similar.

Imagen del ejemplo

Download Descargar ejemplo

Share Button
Categories: Delphi, Ejemplos Tags: ,