Simple Fil De L'Échantillon Delphi

Je suis nouveau dans ce genre de choses de Filetage en Delphi. donc, je suis en train de faire une requête simple application qui faire un peu appel à la base de données et de prendre un peu de temps, je tiens donc à signaler à l'utilisateur qu'il y a un processus d'arrière-plan et d'être patient.

J'ai essayé de nombreux échantillons, mais aucun d'eux de travailler pour moi, s'il vous Plaît, quelqu'un pourrait me montrer un exemple simple qui pourrait fonctionner?

Je sais que je dois Déclarer un Type de TThread, à Créer et à Remplacer Exécuter... etc.. mais depuis que je suis perdu...

À l'aide de Delphi 7, SQL Server 2005 et ADO, Windows XP sp3.-

Grâce.

  • Vous avez essayé de nombreux échantillons et vous avez échoué. Alors, que feriez-vous donner un autre exemple? Vous devriez demander plus détaillée de la question. Ce que vous avez le problème avec? BTW, ce tutoriel a l'air sympa: wiki.lazarus.freepascal.org/Multithreaded_Application_Tutorial
  • Et un de plus, c'est parfois la meilleure solution (parce que c'est plus simple) pour appeler l'Application.ProcessMessages de temps à autre à l'intérieur de votre processus qui prend du temps (par exemple, juste mettre à jour la barre de progression ou de jouer à certains autres animation montrant à l'utilisateur que l'application est occupée).
  • Voici un exemple que j'ai trouvé utile: le Multi-Threading Delphi Requêtes de Base de données
  • SALUT, adf88, je suis totalement d'Accord avec vous. Mais le problème avec les échantillons, c'est que je ne comprend pas tout sur le Fil, alors j'ai pensé à un Simple échantillon pourrait rendre les choses plus claires pour moi. De toute façon, j'ai résolu le problème avec l'Application.Processmessages, Merci
InformationsquelleAutor Jose M. Vilomar | 2010-08-10
  1. 32

    Vous pouvez trouver de nombreux exemples sur le web de fils. La seule particularité, si vous utilisez des connexions ADO à l'intérieur du Fil, c'est que vous ne pouvez pas partager la même connexion.

    Chaque thread doit créer son propre connexion, sinon ils sont égaux (doit suivre les mêmes règles que n'importe quel autre thread.)

    Un exemple que j'ai utilisé est: est-ce

      TADOSQLThread = class(TThread)
  private
    FADOQ: TADOQuery;  // Internal query
    FSQL: string;      // SQL To execute
    FID: integer;      // Internal ID

  public
    constructor Create(CreateSuspended:Boolean; AConnString:String;
                       ASQL:string; IDThread:integer);
    destructor Destroy; override;
    procedure Execute(); override;

    property ID:integer read FID write FID;
    property SQL:string read FSQL write FSQL;
    property ADOQ:TADOQuery read FADOQ write FADOQ;
  end;

    Le Créer constructeur est surdéfini, et ressembler à ceci:

    constructor TADOSQLThread.Create(CreateSuspended:Boolean; AConnString:String;
                                 ASQL:string; IDThread:integer);
begin

  inherited Create(CreateSuspended);

  // ini
  Self.FreeOnTerminate := False;

  // Create the Query
  FADOQ := TAdoquery.Create(nil);
  // assign connections
  FADOQ.ConnectionString := AConnString;
  FADOQ.SQL.Add(ASQL);
  Self.FID := IDThread;
  Self.FSQL:= ASQL;
end;

    Et la méthode execute est très simple:

    procedure TADOSQLThread.Execute();
begin

  inherited;

  try
    // Ejecutar la consulta
    Self.FADOQ.Open;
  except
    // Error al ejecutar
    ...Error treattement
  end;
end;

    De début et de créer un thread, vous pouvez utiliser un code similaire à ceci:

      //crear el Thread
  th := TADOSQLThread.Create(True, mmConnection.Lines.Text, ASQL, AId);
  // internal for me (for controled the number of active threads and limete it)
  inc(numThreads);
  // evento finalizacion
  th.OnTerminate := TerminateThread;
  // Ejecutarlo
  th.Resume;

    J'ai créer un TerminateThread méthode qui reçoivent le contrôle de fils quand ils ont fini. La seule différent des autres threads est le problème de connexion. Vous devez créer une nouvelle connexion dans chaque thread, Il ne peut pas partager la même ADOConnections avec les autres.

    J'espère que cet exemple sera utile pour vous.

    Ce qui concerne

    InformationsquelleAutor Germán Estévez -Neftalí-
  2. 52

    Yup, vous déclarez un nouveau type qui hérite de TThread:

    TMyWorkerThread = class(TThread)
end;

    Puis vous ajoutez une fonction de remplacement pour Execute():

    TMyWorkerThread = class(TThread)
public
  procedure Execute; override;
end;

    Cette procédure sera appelée lorsque vous démarrez votre fil. Il sera exécuté en parallèle avec votre programme principal. Nous allons l'écrire.

    procedure TMyWorkerThread.Execute;
begin
  //Here we do work
   DoSomeWork();
   DoMoreWork();
  //When we exit the procedure, the thread ends.
  //So we don't exit until we're done.
end;

    Comment l'utiliser? Disons que vous voulez commencer à travailler lorsque l'utilisateur clique sur le bouton. Vous écrivez un gestionnaire OnClick:

    procedure TMainForm.Button1Click(Sender: TObject);
begin
  TMyWorkerThread.Create(false);
end;

    Que c'est. Une fois que l'utilisateur clique sur le bouton, votre thread démarre et passe à faire quoi que ce soit que vous avez écrit dans Exécuter. Si l'utilisateur clique sur le bouton de nouveau, un autre thread va commencer, et puis un autre - une à chaque clic. Ils seront tous exécutés en parallèle, chacun faisant tout ce qui est écrit dans le Execute (), puis de la fin.

    Disons que vous voulez vérifier si le travail est terminé. Pour cela, vous aurez à stocker la référence de votre thread quelque part:

    TMainForm = class(TForm)
{...skipped...}
public
  MyWorkerThread: TThread;
end;

procedure TMainForm.Button1Click(Sender: TObject);
begin
  //This time we make sure only one thread can be started.
  //If one thread have been started already, we don't start another.
  if MyWorkerThread<>nil then
    raise Exception.Create('One thread have already been started!');
  MyWorkerThread := TMyWorkerThread.Create(false);
end;

procedure TMainForm.Button2Click(Sender: TObject);
begin
  //If the work is not over yet, we display message informing the user we're still working
  if (MyWorkerThread<>nil) and (WaitForSingleObject(MyWorkerThread.Handle, 0)<>WAIT_OBJECT_0) then
    MessageBox(Self.Handle, pchar("The work is not yet done!"), pchar("Still running"), MB_OK);
end;

    Comme vous le voyez, nous vérifions si un thread est toujours en cours d'exécution par l'appel d'une fonction de Windows appelé WaitForSingleObject. Cette fonction attend jusqu'à ce que le fil est fait de travail, ou lorsque le délai est écoulé, et comme nous le spécifier le délai d'attente de 0, il existe juste immédiatement si le thread n'est pas encore terminée.

    • Je sais ce juste un exemple de code, mais un commentaire en précisant ce qui se passe si l'utilisateur clique sur le bouton plus d'une fois serait utile.
    • Ne pourrait-il pas "TThread" dans le dernier bloc de code de la définition d'un "MyWorkerThread: TMyWorkerThread" à la place?
    • L'idée ici est que vous n'avez pas besoin de connaître ce travail particulier TMyWorkerThread fait savoir que le thread est terminé. Tout TThread descendant peut être vérifiée comme ça.
    • Merci pour l'info. Je ne cherche pas à être tous les smartass ici, mais je suis en traitant avec les threads première fois, et je voulais juste m'assurer que je suis bien... 🙂 Merci pour le bon poste bdw! Aide beaucoup à mieux comprendre le filetage en général...
    • Btw, est-il un autre moyen qui ne repose pas sur la fonction de Windows WaitForSingleObject, afin de cibler d'autres plates-formes?
    • D'accord avec jj sur waitforsingleobj fonction

    InformationsquelleAutor himself