hThread:=BeginThread(Nil,0,Addr(ThreadProc),NewClass,CREATE_SUSPENDED,ConslThrId);

type
TNewClass = class(TOldClass)
  function ThreadProc: DWORD; stdcall;
  function start: boolean;
  hThread: Thandle;
end;

function TNewClass.ThreadProc: DWORD;
begin
  //self is implicit parameter of ThreadProc passed over stack(because stdcall)
  ...
end;

function TNewClass.start: boolean;
begin
  hThread:=BeginThread(Nil,0,Addr(TNewClass.ThreadProc),self,CREATE_SUSPENDED,ConslThrId);
  Result:= hThread <> 0;
end;

function ThreadProc(lpParameter: pointer): DWORD; stdcall;
begin
  Result:= TNewClass(lpParameter).ThreadProc;
end;

Unit NewClass;

interface

Uses Windows, SysUtils, dialogs;

type
 TNewClass = class(TObject)
 hThread: Thandle;
 FID    : Integer;
 ThrID : DWORD;
 function ThreadProc: DWORD; stdcall;
 function start: boolean;
 function Resume: Boolean;
 Constructor Create(ClassID: DWORD); reintroduce;
 Procedure SetID(Value: Integer);
 Property ID: Integer Read FID Write SetID;
end;

implementation

Constructor TNewClass.Create(ClassID: DWORD);
begin
 inherited Create;
 ID := ClassID;
end;

function TNewClass.ThreadProc: DWORD;
var i: WORD;
begin
 //self is implicit parameter of ThreadProc passed over stack(because stdcall)
 ShowMessage(IntToStr(ID));
 for i:=1 to 100 do begin
   OutputDebugStringA(PChar(IntToStr(ID)));
Sleep(100);
 end;
end;

function TNewClass.Resume: Boolean;
begin
 ResumeThread(hThread);
end;

procedure TNewClass.SetID(Value: Integer);
begin
 FID:=Value;
end;

Function ThreadProc(lpParameter: Pointer); stdcall;
begin
 Result:=TNewClass(lpParameter).ThreadProc;
end;

function TNewClass.start: boolean;
begin
 hThread:=BeginThread(Nil,0,Addr(TNewClass.ThreadProc),self,CREATE_SUSPENDED,ThrI d);
 Result:= hThread <> 0;
 Resume;
end;

unit Threads;

interface

uses Windows;

////////////////////////////////////////////////////////////////////////////////
// TThread
////////////////////////////////////////////////////////////////////////////////

type

 TThreadMethod = procedure of object;
 TThreadPriority = (tpIdle, tpLowest, tpLower, tpNormal, tpHigher, tpHighest,
   tpTimeCritical);

const

 Priorities: array [TThreadPriority] of Integer =
   (THREAD_PRIORITY_IDLE,
    THREAD_PRIORITY_LOWEST,
    THREAD_PRIORITY_BELOW_NORMAL,
    THREAD_PRIORITY_NORMAL,
    THREAD_PRIORITY_ABOVE_NORMAL,
    THREAD_PRIORITY_HIGHEST,
    THREAD_PRIORITY_TIME_CRITICAL);

type

 TThread = class
 private
   FHandle: THandle;
   FThreadID: THandle;
   FTerminated: Boolean;
   FSuspended: Boolean;
   FFreeOnTerminate: Boolean;
   FFinished: Boolean;
   FReturnValue: DWORD;
   function GetPriority: TThreadPriority;
   procedure SetPriority(Value: TThreadPriority);
   procedure SetSuspended(Value: Boolean);
 protected
   procedure Execute; virtual; abstract;
   property ReturnValue: DWORD read FReturnValue write FReturnValue;
   property Terminated: Boolean read FTerminated;
 public
   constructor Create(CreateSuspended: Boolean);
   destructor Destroy; override;
   procedure Resume;
   procedure Suspend;
   procedure Terminate;
   procedure WaitFor;
   property FreeOnTerminate: Boolean read FFreeOnTerminate write FFreeOnTerminate;
   property Handle: THandle read FHandle;
   property Priority: TThreadPriority read GetPriority write SetPriority;
   property Suspended: Boolean read FSuspended write SetSuspended;
   property ThreadID: THandle read FThreadID;
 end;

implementation

////////////////////////////////////////////////////////////////////////////////
// TThread
////////////////////////////////////////////////////////////////////////////////

function ThreadProc(Thread: TThread): DWORD;
var
 FreeThread: Boolean;
begin
 Thread.Execute;
 FreeThread := Thread.FFreeOnTerminate;
 Result := Thread.FReturnValue;
 Thread.FFinished := True;
 if FreeThread then Thread.Free;
 EndThread(Result);
end;

//------------------------------------------------------------------------------

constructor TThread.Create(CreateSuspended: Boolean);
var
 Flags: DWORD;
begin
 inherited Create;
 FSuspended := CreateSuspended;
 Flags := 0;
 if CreateSuspended then Flags := CREATE_SUSPENDED;
 FHandle := BeginThread(nil, 0, @ThreadProc, Pointer(Self), Flags, FThreadID);
end;

//------------------------------------------------------------------------------

destructor TThread.Destroy;
begin
 if FHandle <> 0 then CloseHandle(FHandle);
 inherited Destroy;
end;

//------------------------------------------------------------------------------

function TThread.GetPriority: TThreadPriority;
var
 P: Integer;
 I: TThreadPriority;
begin
 P := GetThreadPriority(FHandle);
 Result := tpNormal;
 for I := Low(TThreadPriority) to High(TThreadPriority) do
   if Priorities[I] = P then Result := I;
end;

//------------------------------------------------------------------------------

procedure TThread.SetPriority(Value: TThreadPriority);
begin
 SetThreadPriority(FHandle, Priorities[Value]);
end;

//------------------------------------------------------------------------------

procedure TThread.SetSuspended(Value: Boolean);
begin
 if Value <> FSuspended then
   if Value then
     Suspend
   else
     Resume;
end;

//------------------------------------------------------------------------------

procedure TThread.Suspend;
begin
 FSuspended := True;
 SuspendThread(FHandle);
end;

//------------------------------------------------------------------------------

procedure TThread.Resume;
begin
 if ResumeThread(FHandle) = 1 then FSuspended := False;
end;

//------------------------------------------------------------------------------

procedure TThread.Terminate;
begin
 FTerminated := True;
end;

//------------------------------------------------------------------------------

procedure TThread.WaitFor;
begin
 WaitForSingleObject(FHandle, INFINITE);
end;

//------------------------------------------------------------------------------

end.

type
 { .: TMethodToProc :. }
 TMethodToProc = packed record
   popEax: Byte;
   pushSelf: record
     opcode: Byte;
     Self: Pointer;
   end;
   pushEax: Byte;
   jump: record
     opcode: Byte;
     modRm: Byte;
     pTarget: ^Pointer;
     target: Pointer;
   end;
 end;

{ .: MethodToProcedure :. }
function MethodToProcedure(self: TObject; methodAddr: Pointer): Pointer;
var
 mtp: ^TMethodToProc absolute Result;
begin
 New(mtp);
 with mtp^ do
 begin
   popEax := $58;
   pushSelf.opcode := $68;
   pushSelf.Self := Self;
   pushEax := $50;
   jump.opcode := $FF;
   jump.modRm := $25;
   jump.pTarget := @jump.target;
   jump.target := methodAddr;
 end;
end;

...

constructor TWindow.Create;
begin
 inherited Create();
 ...
 WndProcPtr := MethodToProcedure(Self, @TWindow.WndProc);
 ...
end;

type
 TMyThread = class
 private
   FHandle: THandle;
   FID: Cardinal;
   class function ThreadProc(Param: Pointer): DWord; stdcall; static;
   function Execute: DWord;
 public
   constructor Create;
   destructor Destroy; override;
 end;

{ TMyThread }

constructor TMyThread.Create;
begin
 IsMultiThread := True;
 FHandle := CreateThread(nil, 0, @ThreadProc, Self, 0, FID);
end;

destructor TMyThread.Destroy;
begin
 CloseHandle(FHandle);
 FHandle := 0;
 FID := 0;
 inherited;
end;

class function TMyThread.ThreadProc(Param: Pointer): DWord;
begin
 Result := TMyThread(Param).Execute;
end;

function TMyThread.Execute: DWord;
begin
 MessageBox(0, 'Hello from thread', 'Information', MB_OK or MB_ICONINFORMATION);
 Result := 0;
end;