注册 登陆
浏览模式: 标准 | 列表 分类: DELPHI

Delphi WaitForSingleObject 响应窗体

很不错的咚咚 对线程 然后等待响应 就不会卡死窗体了。

Delphi代码
  1. Repeat   
  2.   Ret :=WaitForSingleObject(hThread,100);   
  3.   Application.ProcessMessages;   
  4. Until Ret <> Wait_Timeout ;  

Delphi 记录类型- 结构指针

转自:万一老师的 Delphi 博客

Delphi代码
  1. unit Unit1;   
  2.   
  3. interface  
  4.   
  5. uses  
  6.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,   
  7.   Dialogs, StdCtrls;   
  8.   
  9. type  
  10.   TForm1 = class(TForm)   
  11.     Button1: TButton;   
  12.     Button2: TButton;   
  13.     Button3: TButton;   
  14.     Button4: TButton;   
  15.     procedure Button1Click(Sender: TObject);   
  16.     procedure Button2Click(Sender: TObject);   
  17.     procedure Button3Click(Sender: TObject);   
  18.     procedure Button4Click(Sender: TObject);   
  19.   end;   
  20.   
  21. var  
  22.   Form1: TForm1;   
  23.   
  24. implementation  
  25.   
  26. {$R *.dfm}  
  27.   
  28. type  
  29.   TRec = record       {定义结构 TRec}  
  30.     name: string[12];   
  31.     age: Word;   
  32.   end;   
  33.   TPRec = ^TRec;      {定义 TRec 结构的指针类型 TPRec}  
  34.   
  35. var  
  36.   Rec:         TRec;    {声明结构变量}  
  37.   PRec1,PRec2: TPRec;   {声明 TPRec 指针变量}  
  38.   PRec3:      ^TRec;    {声明 TRec 结构的指针变量, 现在 PRec1 与 PRec3 是不同类型的变量}  
  39.   P:           Pointer; {声明无类型指针}  
  40.   
  41.   
  42. //通过结构指针访问结构   
  43. procedure TForm1.Button1Click(Sender: TObject);   
  44. begin  
  45.   Rec.name := '张三';   
  46.   Rec.age := 18;   
  47.   
  48.   PRec1 := @Rec; {把 Rec 的地址告诉 PRec1}  
  49.   
  50.   {本来应该这样访问}  
  51.   ShowMessage(PRec1^.name); {张三}  
  52.   
  53.   {Delphi 允许这样简单使用结构指针}  
  54.   ShowMessage(PRec1.name);  {张三}  
  55.   
  56.   {如果我们通过指针修改了数据}  
  57.   PRec1.name := '李四';   
  58.   
  59.   {那么}  
  60.   ShowMessage(Rec.name); {李四}  
  61.   {因为 PRec1 和 Rec 所指的是同一个数据}  
  62. end;   
  63.   
  64.   
  65. //如果是单独使用指针, 必须先给内存   
  66. procedure TForm1.Button2Click(Sender: TObject);   
  67. begin  
  68.   GetMem(PRec2, SizeOf(TRec));   
  69.   PRec2.name := '王五';   
  70.   PRec2.age := 9;   
  71.   
  72.   ShowMessage(PRec2.name); {王五}  
  73.   
  74.   {手工给的内存, 必须手工释放}  
  75.   FreeMem(PRec2);   
  76. end;   
  77.   
  78.   
  79. //虽是同一个结构的指针, 但还不是一个类型   
  80. procedure TForm1.Button3Click(Sender: TObject);   
  81. begin  
  82.   Rec.name := '孙六';   
  83.   Rec.age := 16;   
  84.   
  85.   {把 Rec 的地址给属于 ^Rec 类型的 PRec3 指针}  
  86.   PRec3 := @Rec;   
  87.   ShowMessage(PRec3.name); {孙六}  
  88.   
  89.   {如果要把 PRec3 知道的值告诉 PRec1, 需要类型转换}  
  90.   PRec1 := TPRec(PRec3);   
  91.   ShowMessage(PRec1.name); {孙六}  
  92.   
  93.   
  94.   {反过来想, 如果要把 PRec1 知道的值告诉 PRec3 呢?}  
  95.   Rec.name := '赵七';   
  96.   Rec.age := 24;   
  97.   PRec1 := @Rec;   
  98.   ShowMessage(PRec1.name); {赵七}  
  99.   
  100.   {这样转换}  
  101.   TPRec(PRec3) := PRec1;   
  102.   ShowMessage(PRec3.name); {赵七}  
  103. end;   
  104.   
  105.   
  106. //用无类型指针读写 TRec 中的数据   
  107. procedure TForm1.Button4Click(Sender: TObject);   
  108. begin  
  109.   Rec.name := '杜八';   
  110.   Rec.age := 36;   
  111.   
  112.   P := @Rec;   
  113.   
  114.   {赋值}  
  115.   TPRec(P).name := '侯九';   
  116.   
  117.   {取值}  
  118.   ShowMessage(TPRec(P).name); {侯九}  
  119. end;   
  120.   
  121. end.   

AnsiContainsText 是否包含子串

StrUtils.pas/SysUtils

首部 function AnsiContainsText(const AText, ASubText: string): Boolean; $[StrUtils.pas
功能 返回字符串AText是否包含子串ASubText
说明 不区分大小写
参考 function StrUtils.AnsiUppercase; function StrUtils.AnsiPos
例子 CheckBox1.Checked := AnsiContainsText(Edit1.Text, Edit2.Text);

如何正确给CreateThread传递参数

文章标题:如何正确给CreateThread传递参数?
文章作者:JJony
文章来源:http://blog.csdn.net/jzj_jony

    在网上我们也可以找到相关例子,不过用的是Delphi的TThread类,我个人不太爱用,一个线程也弄

的那么麻烦,不过各有各的好处,这里就不谈论Delphi的TThread类了,我们以在线程里运行MessageBoxA

显示一对话框为例(也就是线程MessageBoxA)。

我们先看看CreateThread的函数定义:

function CreateThread(lpThreadAttributes: Pointer;
                      dwStackSize: DWORD;
                      lpStartAddress: TFNThreadStartRoutine;
                      lpParameter: Pointer;
                      dwCreationFlags: DWORD;
                      var lpThreadId: DWORD): THandle; stdcall;

其中lpStartAddress,lpParameter,lpThreadId三个参数是必须的。
lpStartAddress参数指向的是线程执行体ThreadProc的开始地址;
lpParameter指针类型,线程的传入参数,我们如果想给线程执行体ThreadProc传递我们自己的数据,
           就要通过它了;
lpThreadId返回创建线程ID,这是我们控制线程必须的。

ThreadProc函数定义:
Function ThreadProc(lpParameter:Pointer):DWORD;stdcall;

下面给出具体实例:
因为我们要在线程里执行MessageBoxA所以线程函数可以这样写:

Function ThreadProc(lpParameter:Pointer):DWORD;stdcall;
var
 h:hmodule;
 MyMessagebox:function(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer;stdcall;
begin
 result:=0;
 h:=LoadLibrary('user32.dll');
 if h>0 then
 begin
  @MyMessagebox:=GetProcAddress(h,'MessageBoxA');
  if @MyMessagebox<>nil then
  MyMessageBox(0 ,'线程MessageBoxA测试','提示',0);
  freeLibrary(h);
 end;
end;
创建线程:
createthread(nil,0,@ThreadProc,p,0,TheThread);

上面我们动态调用了MessageBoxA并显示信息,这样就出现了问题,因为我们不可能每显示一个

MessageBoxA消息都要手动定义一个ThreadProc过程,那么我们如何做呢,就是利用lpParameter参数传递
lpParameter是指针类型,而MessageBoxA最主要的两个参数是Title和Msg,因此我们可以定义自己的结构
type
 MYPARA=record
  title:pchar;
  str:pchar;
 end;
PMYPARA=^MYPARA;
这样我们的ThreadProc过程就可以这样写
Function ThreadProc(Para:PMYPARA):DWORD;stdcall;
var
 h:hmodule;
 MyMessagebox:function(hWnd: HWND; lpText, lpCaption: PChar; uType: UINT): Integer;stdcall;
begin
 result:=0;
 h:=LoadLibrary('user32.dll');
 if h>0 then
 begin
  @MyMessagebox:=GetProcAddress(h,'MessageBoxA');
  if @MyMessagebox<>nil then
  MyMessageBox(0 ,Para^.str,Para^.title,0);
  freeLibrary(h);
 end;
end;

创建线程可以这样:
var
  P:PMYPARA;
  ThreadHandle: THandle;
  TheThread: DWORD;
begin
  getmem(p,sizeof(p));//分配内存
  ThreadHandle:=0;
try
  p.title:='测试';    //填充
  p.str:='线程MessageBoxA';
  ThreadHandle:=createthread(nil,0,@ThreadProc,p,0,TheThread);
finally
  if ThreadHandle<>0 then closehandle(ThreadHandle);
  if p<>nil then freemem(p);
end;


至此一个完整的带有参数的CreateThread就完成了,希望对你有所帮助。
如有错误请指教。

TWebBrowser流程讲解及如何判断下载网页成功

procedure TfrmIE2.WebDocumentComplete(Sender: TObject; pDisp: IDispatch;
  var URL: OleVariant);
看见了吧,是OnDocumentComplete事件触发的下载完毕,还会告诉你是那个URL被下载完毕了,非常好用哦.因为页面中如果有IFrame,那么每个IFrame会触发一个DocumentComplete事件.

那我们怎么判断是否全部下载完毕呢?嘿嘿,TWebBrowser控件不是有一个Busy属性的吗?

procedure TfrmIE2.WebDocumentComplete(Sender: TObject; pDisp: IDispatch;
  var URL: OleVariant);
begin
  if not(Web.Busy) then begin
    ShowMessage(´下载完毕´);
  end;
end;
对于每次连接(不论是鼠标点击还是用Navigate2方法连接),TWebBrowser的流程是这样的:

OnBeforeNavigate2          <--开始链接时会触发此事件
OnNavigateComplete2        <--成功的链接到此网页(以后才会有下面的事件)
OnDownloadBegin            <--开始下载
OnDownloadComplete          <--下载结束
OnDocumentComplete          <--页面下载完毕

对于每个HTML页面,顺序都是如此.如果是Frame或IFrame的文件都会当成HTML页面处理.也就是说如果一个页面中有3个IFrame,那么总共会触发4次BeforeNavigate2事件.

对于每个连接且需要显示出来的二进制文件(如*.gif,*.bmp,*.jpg...)都会触发一个DownloadBegin和DownloadComplete事件.

Delphi多线程编程

1-1 多线程的基本概念

      WIN 98/NT/2000/XP 是个多任务操作系统,也就是:一个进程可以划分为多个线程,每个线程轮流占用CPU 运行时间和资源,或者说,把CPU 时间划成片,每个片分给不同的线程,这样,每个线程轮流的“挂起”和“唤醒”,由于时间片很小,给人的感觉是同时运行的。
      多线程带来如下好处:(自己阅读)
      1)避免瓶颈;
      2)并行操作;
      3)提高效率;
      在多线程中,通过优先级管理,可以使重要的程序优先操作,提高了任务管理的灵活性。
      另一方面,在多CPU 系统中,可以把不同的线程在不同的CPU 中执行,真正做到同时处理多任务(Win 98 只是模拟的,而Win/NT/2000是真正的多CPU同时操作)。

      多线程的两个概念:

      1) 进程:也称任务,程序载入内存,并分配资源,称为“一个进程”。
     注意:进程本身并不一定要正在执行。进程由以下几部分组成:
      a>一个私有的地址空间,它是进程可以使用的一组虚拟内存地址空间;
      b>程序的相关代码、数据源;
      c>系统资源,比如操作系统同步对象等;
      d>至少包含一个线程(主线程);

      2) 线程:是程序的执行单位(线程本身并不包括程序代码,真正拥有代码的是进程),每个进程至少包括一个线程,称为主线程,一个进程如果有多个线程,就可以共享同一进程的资源,并可以并发执行。
      线程是进程的一个执行单元,是操作系统分配CPU 时间的基本实体,线程主要由如下两部分组成:
      a>数据结构;
      b>CPU 寄存器和堆栈;
      一个进程中的线程,可以独立运行,也可以控制另一个线程的运行。

      请注意:
      多线程不能滥用,书上提到了多线程的几个缺点(自阅)。

      1-2 Tthread 对象

      虽然Windows 提供了比较多的多线程设计的API 函数,但是直接使用API 函数一方面极其不方便,而且使用不当还容易出错。为解决这个问题,Borland 公司率先推出了一种Tthread 对象,来解决多线程设计上的困难,简化了多线程问题的处理。
      应该注意,Tthread 对象是没有实例的,它和界面的交流,主要依靠主窗体(主VCL线程),这和其他对象使用上有些区别。

     一、Tthread 对象的主要方法

      构造线程:

      constructor Create(CreateSuspended:boolean)

      其中:CreateSuspended=true    构造但不唤醒
                                               false 构造的同时即唤醒

      也可以用如下方法

      inheried Create(CreateSuspended:boolean)


      挂起线程:

      suspend
    
      (把线程挂起的次数加一)

      唤醒线程:

      resume

      (注意:注意这个属性是把线程挂起的次数减一,当次数为0 时,即唤醒。也就是说,线程挂起多少次,唤醒也需要多少次。同时挂起的时候将保持线程的地址指针不变,所以线程挂起后再唤醒,将从挂起的地方开始运行)

      析构(清除线程所占用的内存):

      destroy

      终止线程(后面会具体讨论):

      Terminate

      二、线程应用的简单例子:

      下面通过一个例子说明上述方法的应用。我们知道,循环是独占性最强的运行方式之一,现在希望建立两个线程对象,实现循环的并行运行。具体方法如下:

      File---New---Thread Object

      这就自动在主Form中建立了一个线程单元(在对话框里写上线程名字),默认的名字是Unit2。同样方法建立第二个线程单元Unit3。
    
      要注意的是:Unit2和Unit3中有一个给定的过程:

      procedure Object.Execute;
      begin

      end;

      其中的程序是线程唤醒后自动执行的程序,也可以在里面调用其他自定义的过程和函数。这个过程的结束,意味着线程程序的结束。
      为了构造线程,在interface的Type区,定义一个构造过程:

      type
        Object = class(TThread)    //自动给出的,也可以直接改

        private
     
        protected

           procedure Execute; override;
      
        public
        constructor create;        //自己写的

       并且在implementation区域写上:

       constructor Object.create;
       begin
         inherited create(true);
       end
    
      其中Object 为线程对象的名字。所以这么写,是希望在主Form中调用这个构造过程。
      Create()的参数用True,表明构造出的线程为挂起状态。
      注意一下,在同一个线程对象里,如果两次构造,将产生两个独立的线程,不但运行是独立的,而且使用线程的局部变量也是独立的。但这里为了简化问题,还是建立了两个独立的线程对象,而且两个循环数
是不同的,在并行运算时容易判断出是两个不同的程序在运行。   

      假定我们给两个线程对象起的名字是:

      mymath1
      mymath2

      这样在Unit1,应该作如下声明:
  
      implementation

      {$R *.DFM}

      uses unit2,unit3;

      var thread1:mymath1;
          thread2:mymath2;

      这样在主线程,将可以通过这两个线程变量调用对应的线程方法。

      在主线程区构造线程的方法是:

      thread1:=mymath1.create;
      thread2:=mymath2.create;

      挂起:

      thread1.suspend;
      thread2.suspend;

      唤醒:

      thread1.resume;
      thread2.resume;

      析构:

       thread1.destroy;
       thread2.destroy;     

      这里需要说明的是,由于线程单元需要调用Form的Edit控件(对象),可以采用两种方法:

      1) 在线程单元定义一个TEdit对象,例如

      edit4:Tedit;  

      在Execute过程内直接引用

      但在Unit1中一定要在FormCreate过程里作一个赋值:

      procedure TForm1.FormCreate(Sender: TObject);
      begin
        thread1.edit4:=edit1;
      end;
    
      这样,就把第一线程的edit4与Form上的edit1联系来。

      2)在第二个线程中首先声明调用Unti1,也就是要加上
      Uses Unit1;

      这样就可以在该线程单元直接调用主Form的控件了,比如在Unit3中可以写:

      form1.edit2.text:=inttostr(i)

      了解了这些基本规则,就可以写出比较复杂的多线程程序了。
      还有一点要说明的,默认生成的线程单元,调用的单元只有一个:

      Uses Classes;

      这样,往往很多函数和对象在线程单元里不能使用,所以在必要时,应该根据需要User相应的单元,这个例程为了简单,把大部分常用的单元都拷过去了,这并不是推荐的办法,因为这样一来会使程序的垃圾过
多,所以,一般要用什么拷什么。

      三、常用的API 函数

      在处理多线程问题的时候,也经常用到Windows提供的API 函数,需要说明的是,Tthread 对象内部封装的方法,其实主要也是调用API 函数,但是,考虑更全面,更安全。而直接调用API 函数,往往会因为运用不当,出现一些不应有的错误。所以,我个人以为,只要用Tthread 对象的方法能解决的,就不要直接调用API 函数,API 函数只应该在用在Tthread 对象方法解决不了的时候。
      例如Tthread 对象方法内部调用API 函数的时候,一般使用推荐的默认值,但需要更精细的控制时,就可以直接使用API 函数。
      其实,Tthread 对象方法已经受到了大多数程序设计者的认可,比如,原来VB是不具备直接处理多线程的能力的,但是,现在VB.Net就宣称,它具备了简单处理多线程问题的能力,这就很说明问题。
      下面简单介绍几种API 函数,为了清晰方便,这里着重在于说明,函数正确的描述可以自己阅读书上的例子和手册:
      构建线程:
   
      CreateThread(参数1,--安全属性(一般=Nil,默认安全属性)

                   参数2,--线程堆栈尺寸(一般=0,与主线程相同长度,而且可以根据需要自动变化)
                   参数3,--指向函数名指针,@函数名,这个参数十分重要,不正确将无法调用成功。
                   参数4,--用户需要向线程传递的参数,是一个指向结构的指针,不需传递参数时,为Nil。
                   参数5)--传入与线程有关的一些参数,例如:
                           CREATE_SUSPENDED    创建一个挂起的线程;
                           0 创建后立即激活。

      书上有这个函数应用的十分清晰的例子,可以自己阅读。
      一般并不推荐使用    CreateTheard函数,而推荐使用RTL 库里的System单元中定义的 BeginTheard函数,因为这除了能创建一个线程和一个入口函数以外,还增加了几项保护措施,具体的请参阅书上的第10页说明。

      对应suspend(挂起)和resume(唤醒)的两个API 函数为:
    
      Function SuspendThread(hThread:Thandle):DWORD;

      Function ResumeThread(hThread:Thandle):DWORD;

      其中,Thandle被要求控制线程的句柄,函数调用成功,返回挂起的次数,调用不成功。则返回0xFFFFFFFF。

      四、线程的终止和退出:

      1)自动退出:

      一个线程从Execute()过程中退出,即意味着线程的终止,此时将调用Windows的ExitThread()函数来清除线程所占用的堆栈。
      如果线程对象的 FreeOnTerminate 属性设为True,则线程对象将自动删除,并释放线程所占用的资源。
      这是消除线程对象最简单的办法。

      2)受控退出:

      利用线程对象的Terminate属性,可以由进程或者由其他线程控制线程的退出。只需要简单的调用该线程的Terminate方法,并设直线程对象的Terminate属性为True。
      在线程中,应该不断监视Terminate的值,一旦发现为True,则退出,例如在Execute()过程中可以这样写:

       While not Terminate do
         begin
            ........
         end;        

       3)退出的API 函数:

       关于线程退出的API 函数声明如下:code

       Function TerminateThread(hThread:Thandle;dwExitCode:DWORD);

       不过,这个函数会使代码立刻终止,而不管程序中有没有
       
             try....finally

       机制,可能会导致错误,不到万不得已,最好不要使用。

      4) 利用挂起线程的方法(suspend)

      利用挂起线程的suspend方法,后面跟个Free,也可以释放线程,
例如:
    
      thread1.suspend;    //挂起
      thread2.free;       //释放

      书上有相应的例子。


      五、 线程的优先级:

      在多线程的情况下,一般要根据线程执行任务的重要性,给线程适当的优先级,一般如果量的线程同时申请CPU 时间,优先级高的线程优先。

      在Windows下,给线程的优先级分为30级,而Delphi中Tthread 对象相对简单的把优先级分为七级。也就是在Tthread中声明了一个枚举类型TTthreadPriority:

      type

      TTthreadPriority(tpidle,tpLowest,tpLower,tpNormal,
                       tpHight,tpHighest,tpTimecrital)

      分别对应的是最低(系统空闲时有效,-15),较低(-2),低(-1),正常(普通0),高(1),较高(2),最高(15)。

      其中tpidle和tpTimecrital有些特殊,具体情况请阅读书上有关内容。

      设置优先级可使用thread对象的priority属性:
    
      threadObject.priority:=Tthreadpriority(级别);

      这里给出了一个演示多线程优先级的实例:


     1-3    在数据库中使用多线程

     一)使用ADO模式

      由于Delphi 6.0的ADO 数据源控件内置了多线程能力,所以,在ADO模式下,使用多线程不需要做更多的工作。用两个ADOTable控件,分别连到两个数据库,并且分别通过 DataSource控件,与数据帮定控件联系就可以了,这样就可以实现前后台处理数据库问题。


     二)使用BDE模式和Tseeion对象

      如果需要使用BDE 模式,那么多线程使用数据库,就要考虑Session的问题。在单线程时,每个数据源的建立就自动生成一个Session,这是这个数据源私有的关于数据库信息的文件。但多线程时,必须统一管理,所以在BDE 中专门提供了一个Tsession对象,它可以同时管理不同的Databas数据源对象。
      Databas数据源可以接受来自不同数据平台的数据库。

      数据库1---databas(2)----table(Qurey)(3)---datasource
                   |               |
                   |               |
                   |---------    Tsession(1)
                   |               |
                   |               |
      数据库2---databas(2)----table(Qurey)(3)---datasource


      方法:
      1)Tsession
         属性:SessionName=名(自起)
               Active=true     (激活)
      2)Database(可以有多个)
         属性:SessionName=Tsession名
               Dataname=名(自起,作为Table的标识)
               AliasName=数据库别名
               Connected=True (激活)
      3)Table或Qurey
         属性:SessionName=Tsession名(不要用默认值)
               DatabaseName=如果前面起了名,这里就会出现Database
                            的名字。
               Tablename=表名
               Active=true (激活)
       以后比如加入Datasoucre和其他一样,这样就可以构造两个前后台处理的数据库管理系统了。            

     2-4 多线程的同步机制

      同步机制,实际上是事件驱动机制,意思是让线程平时处于“休眠”状态,除非发生某个事件才触发。
      例如一个拷贝文件,拷贝线程完成一个程序块后,再唤醒进程条线程做一个格的填充。
      研究多线程的同步机制的必要性在于,多线程同步工作时,如果同时调用相同的资源,就可能会出现问题,一般读出是不会有问题的,但是,如果写入(全局变量、数据库),就会发生冲突,甚至产生死
锁和竞争问题。

一、使用Synchronize方法

      这个方法用于访问VCL 主线程所管理的资源,其方法的应用是:
      第一步:把访问主窗口(或主窗口控件资源)的代码放到线程的一个方法中;
      第二步:是在线程对象的Execute方法中,通过Synchronize方法使用该方法。
      实例:
      procedure Theater.Execute;
      begin
        Synchronize(update);      
      end;    

      procedure Theater.update;
      begin
        .........     
      end;      

      这里通过 Synchronize使线程方法update同步。


二、使用VCL类的Look方法

      在Delphi的IDE提供的构件中,有一些对象内部提供了线程的同步机制,工作线程可以直接使用这些控件,比如:Tfont,Tpen, TBitmap,TMetafile,Ticon等。另外,一个很重要的控件对象叫TCanvas,提供了一个Lock方法用于线程的同步,当一个线程使用此控件对象的时候,首先调用这个对象的Lock方法,然后对这个控件进行操作,完毕后再调用Unlock方法,释放对控间的控制权。
      例如:
      CanversObject.look;
           try
             画图
           finally
             CanversObject.unlock;
           end;
      {使用这个保护机制,保证不论有没有异常,unlock都会被执行否则很可能会发生死锁。在多线程设计的时候,应该很注意发生死锁的问题}
     
    

三、Waitfor方法
      当一个线程应该等待另一个线程结束时,可以调用Waitfor方法。这个方法属于等待线程对象,Waitfor方法的原型如下:

      Function Waitfor(Const Astring:string):string;
    
      比如在前面最基本的线程的例子中,唤醒线程的语句中加上

      thread1.resume;
      thread1.waitfor;
      thread2.resume;

      那么所有的线程都必须等待thread1运行完毕后才能运行,其中包括主线程,可以预想,由于thread1调用了主窗体的Edit控件,那么,在thread1运行中间,Edie1也不会显示。
      这就告诉我们,这样的代码是不能作为主线程的一部分的,如果与主窗体连接的线程内等待另一个线程结束,而另一个线程又要等待访问用户界面,就可能是程序陷于死锁。
      这点在应用的时候要谨慎。


四、利用Windows的API 实现同步

      Windows API函数提供了很多同步技术,下面简要介绍。

1)临界区
   
     使用线程的时候,遇到的一个基本的问题,就是多个线程访问同一个对象,比如访问相同的文件、DLL、相同的通讯资源,特别是数据库的访问,当多个线程对同一数据库字段写入的时候,其结果会出
现不确定性。
      临界区用于解决这个问题,它可以保证线程使用敏感数据的时候,阻赛其他的线程访问名干数据,使用时首先要初始化,其声明一个TRTLCriticalSection类型的变量:

var
    CS:TRTLCriticalSection;

初始化:

      initializeCriticalSection(cs);

独占   

EnterCriticalSection(cs);

解除独占

LeaveCriticalSection(CS);

      使用临界区是比较方便而且概念比较清晰的的线程同步机制,应用比较广泛。
      请注意,临界区只能在一个进程内使用,首先要标记出把数据作为临界区操作的那些代码,在这部分代码执行前,计算机首先要查看一下全局记录,已确定是否有其它线程在临界区中,同时也要查看这个临界区是否和第一个临界区相关,也就是说同一个程序中可能会有几个不同的临界区,然后计算机再决定运行策略。

初学线程列子 不知正确否

Delphi代码
  1. unit Unit1;   
  2.   
  3. interface  
  4.   
  5. uses  
  6.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,   
  7.   Dialogs, StdCtrls, Grids, DBGrids, DB, ADODB, ExtCtrls;   
  8.   
  9. type  
  10.   TForm1 = class(TForm)   
  11.     DataSource1: TDataSource;   
  12.     DataSource2: TDataSource;   
  13.     ADOQuery1: TADOQuery;   
  14.     ADOQuery2: TADOQuery;   
  15.     DBGrid1: TDBGrid;   
  16.     DBGrid2: TDBGrid;   
  17.     ADOConnection1: TADOConnection;   
  18.     Panel1: TPanel;   
  19.     Button1: TButton;   
  20.     procedure Button1Click(Sender: TObject);   
  21.   private  
  22.     { Private declarations }  
  23.   public  
  24.     { Public declarations }  
  25.   end;   
  26.   
  27. type  
  28.   TManaDataThread = class(TThread)   
  29.   private  
  30.     //procedure ManagerData;   
  31.     F_sql: string;   
  32.     F_ADOQuery: TADOQuery;   
  33.     procedure GetData;   
  34.   protected  
  35.     procedure Execute; override;    
  36.   public  
  37.     constructor Create(_sql: string; _ADOQuery: TADOQuery);   
  38.   end;   
  39.   
  40. var  
  41.   Form1          : TForm1;   
  42.   
  43. implementation  
  44.   
  45. {$R *.dfm}  
  46.   
  47. { TManaDataThread }  
  48.   
  49. constructor TManaDataThread.Create(_sql: string; _ADOQuery: TADOQuery);   
  50. begin  
  51.   inherited Create(False);   
  52.   F_sql := _sql;   
  53.   F_ADOQuery := _ADOQuery;   
  54. end;   
  55.   
  56. procedure TManaDataThread.Execute;   
  57. begin  
  58.   inherited;   
  59.   while not Terminated do  
  60.   begin  
  61.     Synchronize(GetData);   
  62.   end;   
  63. end;   
  64.   
  65. procedure TForm1.Button1Click(Sender: TObject);   
  66. begin  
  67.   TManaDataThread.Create('select * from Categories ', ADOQuery1);   
  68.   TManaDataThread.Create('select * from Customers', ADOQuery2);   
  69. end;   
  70.   
  71. procedure TManaDataThread.GetData;   
  72. begin  
  73.   F_ADOQuery.Close;   
  74.   F_ADOQuery.SQL.Text := F_sql;   
  75.   F_ADOQuery.Open;   
  76.   Terminate;   
  77. end;   
  78.   
  79. end.   
  80. ----------------------------------------------    
  81. -   

Delphi 对GZIP解压

之前写不出来用了PHP的接口

刚在逛发现一段解压GZIP的代码 我怕下次再遇到这个 那样我就不用发愁了

Delphi代码
  1. 呵呵,终于做出来了,有一定收获,    
  2. 在算法上还是花了不少时间,    
  3. 以前解gzip内容,现在是deflate,少了文件头内容,所以    
  4. 用以前思路老是碰到"data error"问题。    
  5. 用的是zLib控件:    
  6. (http://www.2ccc.com/article.asp?articleid=4269)    
  7.   
  8. 下面是可以运行的代码片断:    
  9. uses ZLibEx;    
  10.   
  11. procedure TForm1.Button3Click(Sender: TObject);    
  12. var    
  13.     url: string;    
  14.     IdHTTP: TIdHTTP;    
  15.     stream, out_stream: TMemoryStream;    
  16. begin    
  17.     url := 'http://bill.finance.sina.com.cn/bill/trade_item.php?stock_code=sh580013&pages=0&time=1218809515';    
  18.     IdHTTP := TIdHTTP.Create(nil);    
  19.   
  20.     stream := TMemoryStream.Create;    
  21.     out_stream := TMemoryStream.Create;    
  22.     try    
  23.         IdHTTP.get(url, stream);    
  24.         stream.Position:=0;    
  25.         ZLibEx.ZDecompressStream2(stream, out_stream, -15);    
  26.         stream.SaveToFile('c:\1.txt');    
  27.         out_stream.SaveToFile('c:\2.txt');  //这个就是我们要的html内容    
  28.     finally    
  29.         stream.Free;    
  30.         out_stream.Free;    
  31.         IdHTTP.Free;    
  32.     end;    
  33. end;    
  34.   
  35.   

Delphi的Query控件使用

Delphi的Query控件

第一点是:区分好Query控件的Open方法和ExecSQL方法。这两个方法都可以实现执行SQL语句,但要根据不同情况分别使用。如果这条SQL语句将返回一个结果集,必须使用Open方法,如果不返回一个结果集,则要使用ExecSQL方法。例如:

  ……

  Query1:Tquery

  Query2:Tquery

  ……

  Query1.Close;

  Query1.SQL.Clear;

  Query1.SQL.Add('select * from AA');

  Query1.Open;

  ……

  Query2.Close;

  Query2.SQL.Clear;

  Query2.SQL.Add('delete AA');

  Query2.ExecSQL;

  ……

  上述的例子中,Query1所执行的SQL语句将返回一个结果集,因此必须用Open方法;而Query2所执行的是一条删除表记录语句,不返回结果集,因此用ExecSQL方法。

  第二点是:如果Query控件用Open方法执行SQL语句,并且所用的SQL语句访问的是一张或几张频繁使用的表,在执行完SQL语句后,一定要调用SQL的FetchAll方法,能大大地减少死锁发生的概率。例如:

  ……

  Query1:Tquery

  ……

  Query1.Close;

  Query1.SQL.Clear;

  Query1.SQL.Add('select * from AA');

  Query1.Open;

  Query1.FetchAll;

  ……

在上述的例子中,如果AA是一张被频繁访问的表,在对这个表执行这一条select语句的同时,如果恰好有其他人对这张表执行删除或更新操作,便有可能发生死锁。Query1.FetchAll这条语句实现的功能是释放加在表AA上的锁,这样死锁的发生概率可以大大减少。避免死锁,对我们将来进行大型数据库开发尤为重要

Delphi中 预编译 实现获取 存储过程返回值

Delphi代码
  1. ADOQuery_A_1.Close;   
  2. ADOQuery_A_1.SQL.Clear;   
  3. ADOQuery_A_1.SQL.Add('Exec XPage ''id'',''Album'',''id'',''id'',''id'',3,13,''Desc'',:Count output');   
  4. ADOQuery_A_1.Open;   
  5. AllRec :=ADOQUery_A_1.Parameters.ParamByName('Count').Value;  

存储过程为XPage 返回值为Count

用预编译形式就能成功返回参数值!