Threads en unit

[[AgustinOrtu]]

No entiendo nada de tu codigo

Por que usas un Syncronize para ejecutar un ShellExecute? Eso ya esta creando un proceso externo a tu aplicacion, no hace falta que sincronices nada

Por que el Application.ProcessMessages?
Por que el CheckSynchronize?

[jhonny]

Empezado por AgustinOrtu

No entiendo nada de tu codigo

Por que usas un Syncronize para ejecutar un ShellExecute? Eso ya esta creando un proceso externo a tu aplicacion, no hace falta que sincronices nada

Por que el Application.ProcessMessages?
Por que el CheckSynchronize?

Bueno, me hago las mismas preguntas, aunque asumí que son "para algo" y ya, por eso mi respuesta.

[[AgustinOrtu]]

Para aplicaciones de consola, si se debe usar CheckSynchronize

Lee la documentacion

Es necesario asignar el valor del metodo a WakeMainThread El problema es que desde una aplicacion con interfaz grafica no deberias tocar esa variable, y usar TThread.Syncronize

Yo me replantearia el diseño

[Ramsay]

El shellexecute es solo un ejemplo , en esa parte del codigo va todo el funcionamiento o el codigo que agregare en el futuro.Estoy estudiando multithreads pero hay muy pocos ejemplos.

[Ramsay]

Perdon , hago otro post porque me olvide de un detalle importante , uso Synchronize porque estoy usandolo en una consola.

[[AgustinOrtu]]

ShellExecute es asincronico, no te sirve para aprender threads

Mejor pon un for de i hasta algun numero muy grande, por ejemplo algun int64

[Ramsay]

Ok , pero el tema principal como lo soluciono ? , intente como dijo jhonny pero aun asi vuelve a lo mismo , o se vuelve eterno o no se ejecuta ninguno.

[[AgustinOrtu]]

Ok esto es muy interesante, admito como siempre que multithreading es dificil y me cuesta dominarlo. Pero encima en consola es distinto porque se te cierra el programa

Esto es lo que invente, es bastante "versatil"

Clase que hereda de TThread:

Código Delphi [-]
unit Unit4;

interface

uses
  Classes;

type
  TThreadInutil = class(TThread)
  private
    FName: string;
    FTope: Int64;
    FUltimoValor: Int64;
  protected
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: Boolean; const AName: string; const ATope: Int64);
    property Name: string read FName;
    property Tope: Int64 read FTope;
    property UltimoValor: Int64 read FUltimoValor;
  end;

implementation

uses
  SysUtils;

constructor TThreadInutil.Create(CreateSuspended: Boolean; const AName: string; const ATope: Int64);
begin
  inherited Create(CreateSuspended);
  FreeOnTerminate := True;
  FName := AName;
  FUltimoValor := 0;
  if FTope > MaxLongint then
    FTope := MaxLongint
  else
    FTope := ATope;
end;

procedure TThreadInutil.Execute;
var
  I: Int64;
begin
  I := 0;
  while (I < Tope) and not Terminated do
  begin
    Inc(I);
    FUltimoValor := I;
    Synchronize(NIL, procedure begin WriteLn(Format('Name: %s I = %d', [Name, I])); end);
  end;
end;

end.

Basicamente cuenta desde 0 hasta el numero que le decimos en el constructor

En el metodo Execute que es reimplementado, imprime el "nombre" y el numero actual en la salida estandar, usando Syncronize

El programa principal crea dos TThreadInutiles, los cuales inician apenas termina su correspondiente constructor.

Luego, hay una pequeña clase TInformador porque el evento OnTerminate es de tipo TNotifyEvent y para agregarle un manejador hay que tener un objeto (TNotifyEvent es un procedure of object, no podes poner un procedimiento suelto, a menos no de forma idiomatica)

El informador recibe la notificacion cuando cada hilo termina su trabajo, y si es el "t1", le agrego una lectura de entrada estandar pidiendo un numero: si es 0 le pedimos al t2 que termine, sino que continue


Hay que consultar el estado de los Thread, si estan trabajando (propiedad Booleana Finished) y si alguno esta haciendo algo, es necesario invocar a CheckSyncronize

Código Delphi [-]
program Project2;
{$APPTYPE CONSOLE}

uses
  SysUtils,
  Classes,
  Unit4 in 'Unit4.pas';

type
  TInformador = class
  public
    procedure ThreadTerminado(Sender: TObject);
  end;

var
  t1, t2: TThreadInutil;
  Informador: TInformador;

procedure TInformador.ThreadTerminado(Sender: TObject);
var
  Num: Integer;
begin
  Writeln(Format('%s Termino: Ultimo Valor %d', [Sender.ClassName, TThreadInutil(Sender).UltimoValor]));

  if Sender = t1 then
  begin
    Writeln('Ingrese 0 para detener t2, cualquier numero para seguir..');
    Readln(Num);
    if Num = 0 then
      t2.Terminate;
  end;
end;

begin
  Informador := TInformador.Create;
  t1 := TThreadInutil.Create(False, 'Thread 1', 1500);
  t2 := TThreadInutil.Create(False, 'Thread 2', 1900);
  try
    t1.OnTerminate := Informador.ThreadTerminado;
    t2.OnTerminate := Informador.ThreadTerminado;
    while not(t1.Finished and t2.Finished) do
      CheckSynchronize;
    try
    except
      on E: Exception do
        Writeln(E.ClassName, ': ', E.Message);
    end;
  finally
    Informador.Free;
    Writeln;
    Writeln('Terminado. Presione ENTER para salir');
    Readln;
  end;

end.