Multithreaded Application Tutorial/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Descripción general
2	2
3	3		En esta página se tratará de explicar cómo escribir y depurar una aplicación multihilo con Free Pascal y Lazarus.
4	4
5	5		Una aplicación multihilo es aquella que crea dos o más hilos de ejecución que trabajan al mismo tiempo.
6	6
7	7		Si eres nuevo en programación multihilo, por favor lee el apartado "¿Necesito multihilo?" para saberlo realmente. Puedes ahorrarte un montón de dolores de cabeza.
8	8
9	9		Uno de los hilos será el Hilo Principal, este es el que crea el Sistema Operativo al arrancar la aplicación.
10	10
11	11		El Hilo Principal debe ser el único hilo que actualice los componentes de la interfaz con el usuario, en caso contrario la aplicación dejará de funcionar.
12	12
13	13		La idea principal es que la aplicación puede hacer alguna tarea en el fondo (en un segundo hilo), mientras que el usuario puede seguir trabajando (con el hilo principal).
14	14
15	15		Otro uso de los hilos es para tener una aplicación que responda mejor. Si crea una aplicación, y cuando el usuario pulsa un botón, la aplicación inicia un proceso (un gran trabajo) ... y durante el proceso, la pantalla deja de responder, el usuario tendrá la sensación de que la aplicación está muerta, lo cual no es agradable. Si la tarea pesada se ejecuta en un segundo hilo, la aplicación puede seguir respondiendo (o casi) como si estuviera desocupada. En este caso es una buena idea, antes de empezar el hilo, desactivar los botones de la ventana para evitar que el usuario inicie de más de un hilo para ese trabajo.
16	16
17	17		Otro uso más, es crear un servidor capaz de responder a muchos clientes al mismo tiempo.
18	18
19	19		## ¿Necesitas múltiples hilos?
20	20
21	21		Si eres novato en esto de los múltiples hilos y lo único que deseas es hacer que tu aplicación responda antes, mientras realiza un trabajo muy pesado, es posible que esto no sea lo que buscas.
22	22
23	23		Las aplicaciones con múltiples hilos de ejecución son siempre más difíciles de depurar y resultan más complejas. Y muchas veces es innecesario, con un solo hilo es suficiente. Se puede dividir la tarea pesada en varios bloques más pequeños, y usar en el lugar adecuado Application.ProcessMessages, que permite a la LCL gestionar los mensajes en espera y continuar después con nuestro código. La idea es realizar una parte del trabajo, llamar a Application.ProcessMessages para comprobar si el usuario hace clic en Cancelar o en algún otro sitio o si es necesario repintar la ventana, y luego continuaremos con la siguiente parte del trabajo, llamaremos de nuevo a Application.ProcessMessages y así sucesivamente.
24	24
25	25		Por ejemplo: Leer un fichero muy grande y procesarlo.
26	26
27	27		Ver ejemplo en \${LazarusDir}/examples/multithreading/singlethreadingexample1.lpi.
28	28
29	29		La programación con múltiples hilos es necesaria únicamente para
30	30
31	31		- Bloqueo de enlaces, como en las comunicaciones de red
32	32		- Utilizar múltiples procesadores a la vez
33	33		- Llamadas a librerías y algoritmos que no pueden ser divididos en partes más pequeñas
34	34
35	35		## La clase TThread
36	36
37	37		El ejemplo que utilizaremos se puede encontrar en el directorio \${LazarusDir}/examples/multithreading/.
38	38
39	39		La manera más fácil de crear una aplicación de múltiples hilos es utilizar la clase TThread. Esta clase permite la creación de un hilo adicional, junto con el hilo principal, de una manera sencilla.
40	40
41	41		Por lo general, sólo tienen que sobrescribir dos métodos: el constructor Create y el método Execute.
42	42
43	43		En el constructor hay que preparar el hilo para su ejecución. Hay que dar el valor inicial a las variables y propiedades que lo precisen. El constructor original de TThread requiere un parámetro llamado Suspended. Como es de esperar, si Suspended es verdadero (true) se evitará que el hilo de comience automáticamente tras la creación. Si el valor del parámetro Suspended es 'false' el hilo se ejecutará inmediatamente después de la creación.
44	44
45	45		Si el hilo se crea suspendido, entonces sólo se ejecutará después de llamar al método Resume.
46	46
47	47		Desde la versión 2.0.1 de PFC TThread.Create tiene además un parámetro implícito para el tamaño de la pila (Stack), con lo que se puede modificar el tamaño de la pila de cada hilo creado si ello es preciso. Un buen ejemplo es la recursión con alto anidamiento de llamadas. Si no se especifica el tamaño de la pila en el parámetro, se utilizará el valor por defecto del SO.
48	48
49	49		En el método Execute sobrescrito se pone el código que deseamos que ejecute el hilo.
50	50
51	51		La clase TThread tiene una propiedad importante:
52	52
53	53		``` pascal
54	54		Terminated : boolean;
55	55		```
56	56
57	57		Si el hilo tiene un bucle (y esto es lo corriente) este debe terminar cuando Terminated es cierto (true), el estado por defecto es 'false'. Por tanto es preciso comprobar el valor de Terminated, y si es 'true' salir del método Execute tan pronto y limpiamente como sea posible.
58	58
59	59		Hay que tener en cuenta que el método Terminate no hace nada por defecto: el método Execute debe realizar explícitamente todas las tareas necesarias para finalizar el trabajo.
60	60
61	61		Como hemos explicado antes, el hilo no debe interactuar con los componentes visibles. Para mostrar algo al usuario hay que hacerlo en el hilo principal. Para hacer esto, TThread tiene un método llamado Synchronize, el cual recibe un parámetro, que consiste en un método de nuestra clase, que a su vez no tiene parámetros. Cuando se llama a este método a través de Synchronize(@MyMethod), la ejecución del hilo se detendrá, el código de MyMethod se ejecutará en el hilo principal y, a continuación se reanudará la ejecución del hilo.
62	62
63	63		El cómo se ejecuta Synchronize depende de la plataforma, pero básicamente hace esto: Coloca un mensaje en la cola de mensajes principal y 'se va a dormir'. En su momento, el hilo principal procesa el mensaje y llama a MyMethod. De esta manera se llama MyMethod sin contexto, es decir que no lo hará durante el desplazamiento del ratón o durante el pintado de la ventana, sino después. Después de que el hilo principal ejecuta MyMethod, despierta al hilo del sueño y procesa el siguiente mensaje. En ese momento el hilo continúa su ejecución.
64	64
65	65		Existe otra propiedad importante de TThread: FreeOnTerminate. Si esta propiedad está a 'true', el hilo se liberará automáticamente al finalizar la ejecución del método 'Execute', en caso contrario hay que liberarlo explícitamente en el código de la aplicación.
66	66
67	67		Ejemplo:
68	68
69	69		``` pascal
70	70		Type
71	71		TMyThread = class(TThread)
72	72		private
73	73		fStatusText : string;
74	74		procedure ShowStatus;
75	75		protected
76	76		procedure Execute; override;
77	77		public
78	78		Constructor Create(CreateSuspended : boolean);
79	79		end;
80	80
81	81		constructor TMyThread.Create(CreateSuspended : boolean);
82	82		begin
83	83		FreeOnTerminate := True;
84	84		inherited Create(CreateSuspended);
85	85		end;
86	86
87	87		procedure TMyThread.ShowStatus;
88	88		// // este es el método que se llamará desde el hilo principal con Synchronize, para acceder a la interfaz.
89	89		begin
90	90		Form1.Caption := fStatusText;
91	91		end;
92	92
93	93		procedure TMyThread.Execute;
94	94		var
95	95		newStatus : string;
96	96		begin
97	97		fStatusText := 'Arrancando TMyThread ...';
98	98		Synchronize(@Showstatus);
99	99		fStatusText := 'Ejecutando TMyThread...';
100	100		while (not Terminated) and ([otra_condición_requerida]) do
101	101		begin
102	102		...
103	103		//[aquí el código del hilo principal]
104	104		...
105	105		if NewStatus <> fStatusText then
106	106		begin
107	107		fStatusText := newStatus;
108	108		Synchronize(@Showstatus);
109	109		end;
110	110		end;
111	111		end;
112	112		```
113	113
114	114		En la aplicación,
115	115
116	116		``` pascal
117	117		var
118	118		MyThread : TMyThread;
119	119		begin
120	120		MyThread := TMyThread.Create(True); // De esta manera no se inicia automáticamente
121	121		...
122	122		//[Aquí el código de inicio necesario antes de que comience la ejecución de los hilos]
123	123		...
124	124		MyThread.Resume;
125	125		end;
126	126		```
127	127
128	128		Si se desea hacer la aplicación más flexible puede crear un evento para el hilo, de esta manera su método sincronizado no estará ligado a un formulario o a una clase específica; y se podrán usar distintos manipuladores para el evento. Aquí hay un ejemplo:
129	129
130	130		``` pascal
131	131		Type
132	132		TShowStatusEvent = procedure(Status: String) of Object;
133	133
134	134		TMyThread = class(TThread)
135	135		private
136	136		fStatusText : string;
137	137		FOnShowStatus: TShowStatusEvent;
138	138		procedure ShowStatus;
139	139		protected
140	140		procedure Execute; override;
141	141		public
142	142		Constructor Create(CreateSuspended : boolean);
143	143		property OnShowStatus: TShowStatusEvent read FOnShowStatus write FOnShowStatus;
144	144		end;
145	145
146	146		constructor TMyThread.Create(CreateSuspended : boolean);
147	147		begin
148	148		FreeOnTerminate := True;
149	149		inherited Create(CreateSuspended);
150	150		end;
151	151
152	152		procedure TMyThread.ShowStatus;
153	153		// este es el método que se llamará desde el hilo principal con Synchronize, para acceder a la interfaz
154	154		begin
155	155		if Assigned(FOnShowStatus) then
156	156		begin
157	157		FOnShowStatus(fStatusText);
158	158		end;
159	159		end;
160	160
161	161		procedure TMyThread.Execute;
162	162		var
163	163		newStatus : string;
164	164		begin
165	165		fStatusText := 'Arrancando MyThread...';
166	166		Synchronize(@Showstatus);
167	167		fStatusText := 'Ejecutando TMyThread...';
168	168		while (not Terminated) and ([otra_condición_requerida]) do
169	169		begin
170	170		...
171	171		//[aquí el código del hilo principal]
172	172		...
173	173		if NewStatus <> fStatusText then
174	174		begin
175	175		fStatusText := newStatus;
176	176		Synchronize(@Showstatus);
177	177		end;
178	178		end;
179	179		end;
180	180		```
181	181
182	182		En la aplicación,
183	183
184	184		``` pascal
185	185		Type
186	186		TForm1 = class(TForm)
187	187		Button1: TButton;
188	188		Label1: TLabel;
189	189		procedure FormCreate(Sender: TObject);
190	190		procedure FormDestroy(Sender: TObject);
191	191		private
192	192		{ private declarations }
193	193		MyThread: TMyThread;
194	194		procedure ShowStatus(Status: string);
195	195		public
196	196		{ public declarations }
197	197		end;
198	198
199	199		procedure TForm1.FormCreate(Sender: TObject);
200	200		begin
201	201		inherited;
202	202		MyThread := TMyThread.Create(true);
203	203		MyThread.OnShowStatus := @ShowStatus;
204	204		end;
205	205
206	206		procedure TForm1.FormDestroy(Sender: TObject);
207	207		begin
208	208		MyThread.Terminate;
209	209		MyThread.Free;
210	210		inherited;
211	211		end;
212	212
213	213		procedure TForm1.Button1Click(Sender: TObject);
214	214		begin
215	215		MyThread.Resume;
216	216		end;
217	217
218	218		procedure TForm1.ShowStatus(Status: string);
219	219		begin
220	220		Label1.Caption := Status;
221	221		end;
222	222		```
223	223
224	224		## Cosas con las que tener especial cuidado
225	225
226	226		En Windows hay un posible problema cuándo se utilizan hilos conjuntamente con el modificador -Ct (comprobar pila). Por razones no muy claras la comprobación de la pila se dispara con todos los TThread.Create si se utiliza el tamaño de pila por defecto. La única solución, por el momento, es simplemente no utilizar el modificador -Ct. Tenga en cuenta que no se producirá una excepción en el hilo principal, pero sí en el hilo recién creado. Es como si el hilo nunca se hubiera iniciado.
227	227
228	228		Un código adecuado para comprobar si esta u otras excepciones pueden ocurrir en la creación del hilo es:
229	229
230	230		``` pascal
231	231		MyThread:=TThread.Create(False);
232	232		if Assigned(MyThread.FatalException) then
233	233		raise MyThread.FatalException;
234	234		```
235	235
236	236		Este código asegura que cualquier excepción que se produzca durante la creación de un hilo será lanzada en su hilo principal.
237	237
238	238		## Unidades necesarias para una aplicación de múltiples hilos
239	239
240	240		No es necesaria ninguna unidad específica para trabajar en Windows. Sin embargo, con Linux, MacOSX y FreeBSD, será necesaria la unidad cthreads que debe ser la primera en la cláusula uses del archivo de programa, .lpr del proyecto.
241	241
242	242		Por lo tanto, el código de la aplicación Lazarus debería ser algo así:
243	243
244	244		``` pascal
245	245		program MiProgramaMultiHilo;
246	246		{$mode objfpc}{$H+}
247	247		uses
248	248		{$ifdef unix}
249	249		cthreads,
250	250		cmem, // el administrador de memoria de c es en algunos sistemas mucho más rápido
251	251		{$endif}
252	252		Interfaces, // this includes the LCL widgetset
253	253		Forms
254	254		{ add your units here },
255	255		```
256	256
257	257		Si no lo haces así, y utilizas TThread, obtendrás este error en el arranque:
258	258
259		-	~~` ``This binary has no thread support compiled in.`\~~
260		-	` ``Recompile the application with a thread-driver in the program uses clause before other units using thread.`
	259	+	``` pascal
	260	+	This binary has no thread support compiled in.
	261	+	Recompile the application with a thread-driver in the program uses clause before other units using thread.
	262	+	```
261	263
262	264		Nota:
263	265
264	266		- Si obtienes un error de enlace de `"mcount" not found` es que se utiliza otra unidad que contiene código de multiproceso y es necesario agregar la unidad cthreads o usar enlace inteligente.
265	267		- Si recibes el error: `"Project raised exception class 'RunError(232)"` en el procedimiento SYSTEM_NOTHREADERROR, es que el código requiere multihilo y hay que añadir la unidad cthreads.
266	268
267	269		### Múltiples hilos en paquetes
268	270
269	271		Los paquetes que usan múltiples hilos debe añadir el indicador -dUseCThreads en las opciones del compilador. Abra el paquete, y en el editor, pulsa el botón 'Opciones', en la pestaña 'Uso' y agrega -dUseCThreads en la opción 'Personalizado' . Con esta operación se definirá esta opción para todos los proyectos y paquetes que utilicen este paquete, incluyendo el IDE. El IDE y todas las nuevas aplicaciones creadas por el IDE tendrán entonces el siguiente código en su archivo .lpr :
270	272
271	273		``` pascal
272	274		uses
273	275		{$IFDEF UNIX}{$IFDEF UseCThreads}
274	276		cthreads,
275	277		{$ENDIF}{$ENDIF}
276	278		```
277	279
278	280		## Soporte para Sistema de Multiproceso Simétrico (SMP)
279	281
280	282		Las buenas noticias es que si tu aplicación funciona correctamente con múltiples hilos de esta forma, está también preparado para SMP.
281	283
282	284		## Depurando aplicaciones de múltiples hilos con Lazarus
283	285
284	286		La depuración en Lazarus necesita GDB y está siendo rápidamente más y más funcional y estable. No obstante, hay distribuciones Linux con algunos problemas.
285	287
286	288		### Salida de la depuración
287	289
288	290		En una aplicación de un único hilo simplemente se escribe en la consola o terminal y las líneas son escritas en el orden adecuado. En una aplicación de múltiples hilos las cosas son más complicadas. Si dos hilos están escribiendo, por ejemplo una línea escrita por un hilo A antes que una línea del hilo B, no son necesariamente escritas en ese orden. Puede incluso suceder que un hilo escriba su salida, mientras el otro hilo está escribiendo una línea.
289	291
290	292		La unidad LCLProc contiene varias funciones, para que cada hilo escriba su propio archivo de registro:
291	293
292	294		``` pascal
293	295		procedure DbgOutThreadLog(const Msg: string); overload;
294	296		procedure DebuglnThreadLog(const Msg: string); overload;
295	297		procedure DebuglnThreadLog(Args: array of const); overload;
296	298		procedure DebuglnThreadLog; overload;
297	299		```
298	300
299	301		Por ejemplo: En lugar de writeln('Algo de texto ',123); utiliza DebuglnThreadLog(\['Algo de texto ',123\]);, de esta manera se añade la línea 'Algo de texto 123' al archivo Log\<PID\>.txt, donde PID es el ID del hilo actual.
300	302
301	303		Es una buena idea eliminar los archivos de registro después de cada ejecución:
302	304
303		-	~~` rm -f Log* && ./project1`~~
	305	+	```text
	306	+	rm -f Log* && ./project1
	307	+	```
304	308
305	309		### Linux
306	310
307	311		Si intentas depurar una aplicación de múltiples hilos en Linux, tendrás un gran problema: el servidor X se colgará. Si te ocurre esto, simplemente sal de la sesión y crea una nueva presionando CTRL+ALT+F3. Esto abre una sesión de consola, en ella escribimos sudo /etc/init.d/gdm restart; con esto rearrancamos el gestor gráfico de escritorio, y regresamos al mismo.
308	312
309	313		Una forma de resolver este problema en ubuntu x64 es configurar las opciones de proyecto en depuración para requerir un fichero de información adicional...
310	314
311		-	~~` Proyecto -> Opciones del Compilador... -> Enlazando -> Depurando: marcar la opción ``Usar archivo externo de símbolos de depuración para gdb (-Xg)``.`~~
	315	+	```text
	316	+	Proyecto -> Opciones del Compilador... -> Enlazando -> Depurando: marcar la opción Usar archivo externo de símbolos de depuración para gdb (-Xg).
	317	+	```
312	318
313	319		Si lo anterior no funciona prueba este remedio:
314	320
315	321		Crear una nueva instancia del servidor X con:
316	322
317		-	~~` X :1 &`~~
	323	+	```text
	324	+	X :1 &
	325	+	```
318	326
319	327		Se abrirá un escritorio gráfico, y podrás cambiar al escritorio en que estabas trabajando pulsando CTRL + ALT + F7, y volver al nuevo escritorio con CTRL + ALT + F8 (si esta combinación no funciona, prueba con CTRL + ALT + F2 ... ésto funciona en Slackware)
320	328
321	329		Ahora se puede, si se desea, crear una sesión de escritorio en el servidor X recién arrancado con:
322	330
323		-	~~` gnome-session --display=:1 &`~~
	331	+	```text
	332	+	gnome-session --display=:1 &
	333	+	```
324	334
325	335		Luego, en Lazarus, en los parámetros de ejecución del proyecto en la pestaña Local, marcar "Usar pantalla" y escribimos ':1'.
326	336
327	337		Ahora la aplicación se ejecutará en el segundo servidor X y podremos depurar en el primero.
328	338
329	339		Los procedimientos señalados ha sido probados con FreePascal 2.0 y Lazarus 0.9.10 en Windows y Linux.
330	340
331	341		------------------------------------------------------------------------
332	342
333	343		En lugar de crear una nueva sesión de X, se puede utilizar [Xnest](http://en.wikipedia.org/wiki/Xnest). Xnest es una sesión X en una ventana. Usándola el servidor X no se bloquea al depurar los hilos, y es mucho más fácil depurar sin tener que cambiar entre terminales.
334	344
335	345		La segunda línea para ejecutar Xnest es
336	346
337		-	~~` Xnest :1 -ac`~~
	347	+	```text
	348	+	Xnest :1 -ac
	349	+	```
338	350
339	351		para crear una sesión X en :1, y deshabilitar el control de acceso.
340	352
341	353		## Artefactos Widgetsets
342	354
343	355		Las interfaces de win32, la de gtk y la de carbon soportan completamente la programación con múltiples hilos. Esto significa, que la clase TThread, las secciones críticas (TCriticalSection) y la sincronización (Synchronize) funcionarán.
344	356
345	357		Pero los subprocesos no son seguros. Esto significa que sólo un hilo a la vez puede acceder a la LCL. Y puesto que el hilo principal no debe esperar a otro hilo, sólo al hilo principal se le permite acceder a la LCL, lo que significa que se ocupará de cualquier cosa que tenga que ver con TControl, Application o los componentes de la LCL.
346	358
347	359		Hay algunas funciones de hilo seguro en la LCL. Por ejemplo la mayoría de las funciones de la unidad FileUtil son seguras para subprocesos.
348	360
349	361		## Secciones Críticas
350	362
351	363		Una sección crítica es un objeto utilizado para hacer asegurar que cierto código es ejecutado únicamente por un único hilo en un momento dado. La sección círitica debe ser creada e iniciada antes de ser utilizada y debe ser liberada cuándo deje de ser necesaria.
352	364
353	365		Las secciones críticas se utilizan habitualmente de esta forma:
354	366
355	367		Añadir la unidad SyncObjs.
356	368
357	369		Declarar la sección globalmente para todos los hilos que deban acceder a la sección:
358	370
359	371		``` pascal
360	372		MyCriticalSection: TRTLCriticalSection;
361	373		```
362	374
363	375		Crear e iniciar la sección:
364	376
365	377		``` pascal
366	378		InitializeCriticalSection(MyCriticalSection);
367	379		```
368	380
369	381		Ejecutar algunos hilos. Hacer algo que necesite exclusividad
370	382
371	383		``` pascal
372	384		EnterCriticalSection(MyCriticalSection);
373	385		try
374	386		// acceder a algunas variables, escribir archivos, enviar algunos paquetes de red, etc.
375	387		finally
376	388		LeaveCriticalSection(MyCriticalSection);
377	389		end;
378	390		```
379	391
380	392		Después de terminar todos los hilos, liberar la sección crítica:
381	393
382	394		``` pascal
383	395		DeleteCriticalSection(MyCriticalSection);
384	396		```
385	397
386	398		Como alternativa, puede utilizar un objeto TCriticalSection. La creación del objeto realiza el inicio, el método Enter realiza la función de EnterCriticalSection, el método Leave ejecuta LeaveCriticalSection y la destrucción del objeto lleva a cabo la terminación y liberación de recursos.
387	399
388	400		Por ejemplo: 5 hilos incrementan un contador. Ver \${LazarusDir}/examples/multithreading/criticalsectionexample1.lpi
389	401
390	402		Cuidado: Hay dos conjuntos de las 4 funciones mencionadas. Un conjunto de la RTL y otra de la LCL. Las funciones de la LCL están definidas en las unidades LCLIntf y LCLType. Ambos conjuntos trabajan de forma muy parecida. Puede utilizar ambas al mismo tiempo en su aplicación, pero no se debe utilizar una función de RTL con una sección crítica de la LCL, y a la inversa.
391	403
392	404		### Compartiendo variables
393	405
394	406		Si varios hilos comparten una variable, que es de sólo lectura, no hay de que preocuparse, simplemente léela. Pero si uno o varios hilos cambian el valor de la variable, entonces hay que asegurar que únicamente un hilo accede a la variable en un momento dado.
395	407
396	408		Por ejemplo: 5 hilos incrementan un contador. Ver \${LazarusDir}/examples/multithreading/criticalsectionexample1.lpi
397	409
398	410		## Esperando a otro hilo
399	411
400	412		En caso de que un hilo A necesite un resultado de otro hilo B, deberá esperar hasta que B termine su ejecución.
401	413
402	414		Importante: El hilo principal nunca debe esperar a otro hilo. En lugar de eso utilice Synchronize (ver más arriba)
403	415
404	416		Véase, por ejemplo: \${LazarusDir}/examples/multithreading/waitforexample1.lpi
405	417
406	418		``` pascal
407	419		{ TThreadA }
408	420		procedure TThreadA.Execute;
409	421		begin
410	422		Form1.ThreadB:=TThreadB.Create(false);
411	423		WaitForB:=RTLEventCreate; //Crear el evento
412	424		while not Application.Terminated do begin
413	425		RtlEventWaitFor(WaitForB); // esperar indefinidamente (hasta que A es despertado por B)
414	426		writeln('A: Contador del hilo B='+IntToStr(Form1.ThreadB.Contador));
415	427		end;
416	428		end;
417	429
418	430		{ TThreadB }
419	431		procedure TThreadB.Execute;
420	432		var
421	433		i: Integer;
422	434		begin
423	435		Contador:=0;
424	436		while not Application.Terminated do begin
425	437		// B: trabajando ...
426	438		Sleep(1500);
427	439		inc(Contador);
428	440		// despertar A
429	441		RtlEventSetEvent(Form1.ThreadA.WaitForB);
430	442		end;
431	443		end;
432	444		```
433	445
434	446		## Réplica (Fork)
435	447
436	448		Cuándo replicamos una aplicación con múltiples hilos, hay que tener presente que los hilos han de ser creados y estar en funcionamiento antes de realizar la replica (fork o fpFork, ya que no pueden ejecutarse en el proceso hijo. Como se indica en el manual de fork(), el estado de los los hilos que se ejecutan antes de la bifurcación será indefinido.
437	449
438	450		Por lo tanto, hay que tener en cuenta que cualquier hilo iniciado antes de la llamada (incluidos los de la sección de inicio), no va a funcionar.
439	451
440	452		## Computación distribuida
441	453
442	454		El siguiente gran paso, después de programar múltiples hilos, es hacer que estos se ejecuten en múltiples máquinas.
443	455
444	456		- Se puede usar algún paquete de TCP como synapse, lnet o Indy para las comunicaciones. Esto proporciona la máxima flexibilidad y se usa principalmente para aplicaciones cliente / servidor con conexiones ligeras.
445	457		- Se puede usar librerías de envío de mensajes, como [[MPICH]], que se utilizan para Computación de Altas Prestaciones (HPC, High Performance Computing) sobre grupos de ordenadores (clusters).
446	458
447	459		## Hilos externos
448	460
449	461		Para hacer que el sistema de hilos de Free Pascal funcione correctamente, cada nuevo hilo FPC tiene que ser iniciado (más exactamente, las excepciones, el sistema de E/S y el sistema threadvar por hilo tiene que ser iniciado ya que threadvars y la pila ya están trabajando). Esto es totalmente automático si utilizas BeginThread (o indirectamente mediante la clase TThread). Sin embargo, si utilizas los hilos que se crearon sin BeginThread (es decir, hilos externos), trabajo adicional (actualmente) podría ser necesario. En hilos externos se incluyen los que fueron creados en librerías C externas (.DLL/.so).
450	462
451	463		Cosas ha considerar cuando se utilizan hilos externos (podría no ser necesario en todas o en futuras versiones del compilador):
452	464
453	465		- No utilices hilos externos en absoluto; usa hilos FPC. Si puedes conseguir el control sobre cómo el hilo se crea, crea el hilo por tí mismo mediante el uso de BeginThread.\
454	466
455	467		Si la convención de llamada no se ajusta (v.g. si tu función original del hilo necesita llamadas con convención cdecl, pero BeginThread necesita convención Pascal, crea un registro, guarda la función requerida original de hilos en ella, y llama a esa función en la función pascal del hilo:
456	468
457	469		``` pascal
458	470		type
459	471		TCdeclThreadFunc = function (user_data:Pointer):Pointer;cdecl;
460	472
461	473		PCdeclThreadFuncData = ^TCdeclThreadFunc;
462	474		TCdeclThreadFuncData = record
463	475		Func: TCdeclThreadFunc; //cdecl function
464	476		Data: Pointer; //original data
465	477		end;
466	478
467	479		// el hilo pascal llama al función cdecl
468	480		function C2P_Translator(FuncData: pointer) : ptrint;
469	481		var
470	482		ThreadData: TCdeclThreadFuncData;
471	483		begin
472	484		ThreadData := PCdeclThreadFuncData(FuncData)^;
473	485		Result := ptrint(ThreadData.Func(ThreadData.Data));
474	486		end;
475	487
476	488		procedure CreatePascalThread;
477	489		var
478	490		ThreadData: PCdeclThreadFunc;
479	491		begin
480	492		New(ThreadData);
481	493		// esta es la función cdecl deseada hilo
482	494		ThreadData^.Func := func;
483	495		ThreadData^.Data := user_data;
484	496		// this creates the Pascal thread
485	497		BeginThread(@C2P_Translator, ThreadData );
486	498		end;
487	499		```
488	500
489	501		- Inicia el sistema de hilos de FPC mediante la creación de un hilo vacío. Si no creas ningún hilo Pascal en tu aplicación, el sistema de hilos no se puede iniciar (y por tanto threadvars no funcionará y por lo tanto la pila no funcionará correctamente).
490	502
491	503		``` pascal
492	504		type
493	505		tc = class(tthread)
494	506		procedure execute;override;
495	507		end;
496	508
497	509		procedure tc.execute;
498	510		begin
499	511		end;
500	512
501	513		{ programa principal }
502	514		begin
503	515		{ Inicia el sistema de hilos }
504	516		with tc.create(false) do
505	517		begin
506	518		waitfor;
507	519		free;
508	520		end;
509	521		{ ... aquí sigue tu código }
510	522		end.
511	523		```
512	524
513	525		(Después de que el sistema de hilos se inicia, el nucleo de ejecución establece la variable del sistema "IsMultiThread" a verdadero, lo que es utilizado por las rutinas FPC para realizar bloqueos aquí y allá. No se debe establecer esta variable de forma manual)
514	526
515	527		- Si por alguna razón esto no te funciona, prueba este código en tu función de hilo externo:
516	528
517	529		``` pascal
518	530		function ExternalThread(param: Pointer): LongInt; stdcall;
519	531		var
520	532		tm: TThreadManager;
521	533		begin
522	534		GetThreadManager(tm);
523	535		tm.AllocateThreadVars;
524	536		InitThread(1000000); // ajustar el tamaño de pila inicial aquí
525	537
526	538		{ hacer algo con hilos aquí ... }
527	539
528	540		Result:=0;
529	541		end;
530	542		```
531	543
532	544		### Identificando hilo externos
533	545
534	546		A veces incluso no sabes si tienes que tratar con hilos externos (v.g, si alguna librería C hace una retrollamada -callback-). Esto puede ayudar a analizar esto:
535	547
536	548		1\. Pregunta al S.O. el identificador del subproceso actual al inicio de tu aplicación
537	549
538	550		``` pascal
539	551		Win32: GetCurrentThreadID();
540	552		Darwin: GetThreadID();
541	553		Linux: TThreadID(pthread_self);
542	554		```
543	555
544	556		2\. Pregunta por el ID del hilo actual, dentro de la función del hilo y compáralo con el resultado del paso 1.
545	557
546	558		## See also
547	559
548	560		- [[Streaming components]]
549	561		- [[Manager Worker Threads System]]
550	562		- [[Example of multi-threaded application: array of threads/es\|Ejemplo de una aplicación con múltiples hilos: Matriz de hilos]]
551	563		- [[Parallel procedures]]
552	564
553	565		## Contribuciones
554	566
555	567		- Versión en castellano (español) iskraelectrica (jldc) / julio de 2008.
556	568
557	569		---
558	570		From the Free Pascal wiki, page "Multithreaded Application Tutorial/es", as it stood on 2020-02-20 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history