一台计算机建立N多个TCP Client Socket与服找医药进销存管理软件

销售管理软件版1楼: 如题：一台计算机建立N多个TCP Client Socket与服务端通讯问题
现在有一数据服务端(TCP协议)，我现在要做的是在一台计算机上实现5000个client socket与之建立连接．而且要长时间保持连接
我想了想，采用多线程，每个socket client一个线程。5000个连接5000个线程。系统吃不消。。。。所以不可行。如果建立一个线程专门管理socket消息。不知道此方应该如何实现？请在大家发表下各自的高见。谢谢了

2楼: 拜托,还是用udp吧,tcp是有连接方式,服务器会吃不消的如速达财务软件单机版

3楼: 服务端采用的就是TCP协议,这是不可改变的丫!

4楼: 不能长期保持连接状态。操作完了就要释放。

5楼: [:(][:(!][:(!]

6楼: 没注意看帖,sorry!

销售管理软件版7楼: 你的服务器什么配置？？

8楼: P4 3.0双至强处理器, 2G 内存

9楼: 完成端口+线程池
不过长时间连接......很麻烦...
或许可以学习一下做网络平衡的那些家伙.不过底层需要改动太多

10楼: 用indy要好些。

11楼: jingtao：您好，现在需要写的是客户端而不是服务端，完成端口我一直以为他只适合做服务端。如果做客户端的话，不知道有没有好的实现方法呢？我曾经写过一个IOCP的组件(BST IOCP)。不过不知道如何写这种客户端的应用。还请大家指教一下。

关于网络平衡，我真的是一窍不通……

12楼: 服务器端弄多个端口如手机记账理财软件

13楼: 服务端不是我写的，是别人的．．．．所以不能有任何的改动

销售管理软件版14楼: 试试ｊｉｎｔａｏ提到的线程池吧
客户端这么做，少见
关注一下

15楼: 就是，5000 晕了，
ｊｉｎｔａｏ提到的线程池吧
没有用过，没有发言权

16楼: 因为这个软件本身并不是单纯的TCP连接，具体的工作方式是每个单独的连接比必须完成特定的数据交互工作．而且数据交互很频繁！
如果采用线程池的话，能不能给个比较好的思路呢？

17楼: 不明白为什么一定要在一台电脑上面建立5000个客户端....这样线程池用处也不大的.
线程池一般用于服务端编程.例如游戏服务器等.其实也就是建立一定的线程,结束后并不释放而是保存下来给下一个线程使用.目的是减少系统开销(线程的建立和FREE是需要系统开销的).但是并不适用于你这种客户端的情况.

18楼: 在一台电脑上面建立5000个客户端？
用来攻击服务器？？？

19楼: 现在的测试要求我也没办法呀，还请高手指点一二．
我朋友用VC就实现，而我用delphi写的老是会断，真是郁闷．而我也是用API来实现的

20楼: ＂在一台计算机上实现5000个client socket与之建立连接．而且要长时间保持连接＂, 不会吧,什么系统要这么实现,有点怪!

楼主能否使用别的方法来实现呢.

销售管理软件版21楼: 能不能实现5000个客户端同时链接我不知道,但是我知道在2000上是肯定不行!

线程池就是程序启动的时候起若干个空线程,不停的扫描一个公共的任务列表,当任务列表里有N个任务,那么线程池里的线程就会每个线程顺序的抓取一个任务来执行,直到完成.以下是个简单的DEMO

主窗体
unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, CheckLst, Unit2, ExtCtrls;

type
TForm1 = class(TForm)
Label1: TLabel;
CheckListBoxTasks: TCheckListBox;
ButtonAddRandomTask: TButton;
ButtonStopCurTask: TButton;
ButtonPauseTask: TButton;
ButtonExit: TButton;
ButtonAddTask: TButton;
EditTaskTime: TEdit;
ButtonDelTask: TButton;
ButtonContinueTask: TButton;
TimerRefreshList: TTimer;
procedure ButtonAddTaskClick(Sender: TObject);
procedure ButtonAddRandomTaskClick(Sender: TObject);
procedure ButtonStopCurTaskClick(Sender: TObject);
procedure ButtonPauseTaskClick(Sender: TObject);
procedure ButtonContinueTaskClick(Sender: TObject);
procedure ButtonDelTaskClick(Sender: TObject);
procedure ButtonExitClick(Sender: TObject);
procedure TimerRefreshListTimer(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
private
{ Private declarations }
FTaskList: TTaskList;
FTaskIdx: Integer;
FThreads: array of TTaskThread;
public
{ Public declarations }
end;

var
Form1: TForm1;

const
THREAD_COUNT = 4;

implementation

{$R *.dfm}

procedure TForm1.ButtonExitClick(Sender: TObject);
begin
Close;
end;

procedure TForm1.ButtonAddTaskClick(Sender: TObject);
begin
Inc(FTaskIdx);
FTaskList.AddTask(Format(＇＇Task%d＇＇, [FTaskIdx]),
StrToIntDef(EditTaskTime.Text, 1000));
end;

procedure TForm1.FormCreate(Sender: TObject);
var
I: Integer;
begin
FTaskList := TTaskList.Create;
FTaskIdx := 0;
Randomize;
SetLength(FThreads, THREAD_COUNT);
for I := 0 to High(FThreads) do
FThreads[I] := TTaskThread.Create(FTaskList);
end;

procedure TForm1.FormDestroy(Sender: TObject);
var
I, J: Integer;
begin
for I := 0 to High(FThreads) do
FThreads[I].Terminate;
for I := 0 to High(FThreads) do
while FThreads[I].Suspended do
FThreads[I].Resume;
for I := 0 to High(FThreads) do
begin
//等待线程退出
while WaitForSingleObject(FThreads[I].Handle, 0) <> WAIT_OBJECT_0 do
for J := 0 to 1000 do
Application.ProcessMessages;
end;

FTaskList.Free;
end;

procedure TForm1.TimerRefreshListTimer(Sender: TObject);
var
AList: TList;
Item: PTaskRecord;
I, C: Integer;
S: string;
begin
AList := FTaskList.LockList;
try
C := CheckListBoxTasks.Count;
if CheckListBoxTasks.Count < AList.Count then

for I := AList.Count - 1 downto CheckListBoxTasks.Count do
begin
Item := AList.Items[I];
S := Format(＇＇%s %d %s %d%%＇＇, [Item.Name, Item.Time,
TTaskStatusNames[Item.Status], Round(Item.DoneTimes / Item.Time * 100)]);
CheckListBoxTasks.Items.Add(S);
end;

if CheckListBoxTasks.Count > AList.Count then
begin
C := AList.Count;
for I := CheckListBoxTasks.Count - 1 downto AList.Count - 1 do
CheckListBoxTasks.Items.Delete(I);
end;

for I := C - 1 downto 0 do
begin
Item := AList.Items[I];
S := Format(＇＇%s %d %s %d%%＇＇, [Item.Name, Item.Time,
TTaskStatusNames[Item.Status], Round(Item.DoneTimes / Item.Time * 100)]);
if CheckListBoxTasks.Items.Strings[I] <> S then
CheckListBoxTasks.Items.Strings[I] := S;
end;

finally
FTaskList.UnlockList;
end;

for I := 0 to High(FThreads) do
if FThreads[I].Suspended then

FThreads[I].CheckTask;
end;

procedure TForm1.ButtonAddRandomTaskClick(Sender: TObject);
begin
Inc(FTaskIdx);
FTaskList.AddTask(Format(＇＇Task%d＇＇, [FTaskIdx]),
Random(3000) + 1000);
end;

procedure TForm1.ButtonDelTaskClick(Sender: TObject);
var
ID: Integer;
begin
if CheckListBoxTasks.ItemIndex >= 0 then
begin
ID := CheckListBoxTasks.ItemIndex;
if FTaskList.Items[ID].Status <> tsRunning then
CheckListBoxTasks.DeleteSelected;
FTaskList.DelTask(ID);
if CheckListBoxTasks.Count > ID then
CheckListBoxTasks.ItemIndex := ID;
end;
end;

procedure TForm1.ButtonStopCurTaskClick(Sender: TObject);
begin
if CheckListBoxTasks.ItemIndex >= 0 then
FTaskList.TaskCommand(CheckListBoxTasks.ItemIndex, tcStop);
end;

procedure TForm1.ButtonPauseTaskClick(Sender: TObject);
begin
if CheckListBoxTasks.ItemIndex >= 0 then
FTaskList.TaskCommand(CheckListBoxTasks.ItemIndex, tcPause);

end;

procedure TForm1.ButtonContinueTaskClick(Sender: TObject);
begin
if CheckListBoxTasks.ItemIndex >= 0 then
FTaskList.TaskCommand(CheckListBoxTasks.ItemIndex, tcRun);
end;

end.

线程单元
unit Unit2;

interface

uses
Classes, Windows, SysUtils;

type
//状态：未知，等待，运行，暂停，完成
TTaskStatus = (tsUnknow, tsWaiting, tsRunning, tsPause, tsFinished);
//命令：无，运行，暂停，停止
TTaskCommandd = (tcNone, tcRun, tcPause, tcStop);

TTaskRecord = record
Name: string;
Time: Integer;
Command: TTaskCommandd;
Status: TTaskStatus;
DoneTimes: Integer;
end;
PTaskRecord = ^TTaskRecord;

TTaskList = class(TThreadList)
private
function GetItems(Index: Integer): TTaskRecord;
procedure SetItems(Index: Integer; const Value: TTaskRecord);
function SetCount: Integer;
{ Private declarations }
protected

public
destructor Destroy; override;

procedure AddTask(AName: string; ATime: Integer);
procedure DelTask(Index: Integer);
procedure TaskCommand(Index: Integer; Command: TTaskCommandd);
property Count:Integer read SetCount;
property Items[Index: Integer]: TTaskRecord read GetItems write SetItems;
end;

TTaskThread = class(TThread)
private
FTaskList: TTaskList;
FCurTask: PTaskRecord;
FRunTimes: Integer;
function GetTaskFinished: Boolean;
{ Private declarations }
protected
procedure Execute; override;
public
procedure CheckTask;
constructor Create(TaskList: TTaskList);

property TaskFinished: Boolean read GetTaskFinished;
end;

const
TTaskStatusNames: array[TTaskStatus] of string =
(＇＇未知＇＇, ＇＇等待＇＇, ＇＇运行＇＇, ＇＇暂停＇＇, ＇＇完成＇＇);

implementation

uses Unit1;

{ TTaskList }

function TTaskList.SetCount: Integer;
var
AList: TList;
begin
AList := LockList;

try
Result := AList.Count;
finally
UnlockList;
end;
end;

procedure TTaskList.AddTask(AName: string; ATime: Integer);
var
AList: TList;
Item: PTaskRecord;
begin
AList := LockList;
try
Item := New(PTaskRecord);
Item.Name := AName;
Item.Time := ATime;
Item.DoneTimes := 0;
Item.Command := tcNone;
Item.Status := tsWaiting;
AList.Add(Item);
finally
UnlockList;
end;
end;

procedure TTaskList.DelTask(Index: Integer);
var
AList: TList;
Item: PTaskRecord;
begin
AList := LockList;
try
Item := AList.Items[Index];
if Item.Status = tsRunning then
begin
Item.Command := tcPause;
Exit;
end;
AList.Remove(Item);
Dispose(Item);
finally
UnlockList;
end;
end;

destructor TTaskList.Destroy;
var
AList: TList;
Item: PTaskRecord;
I: Integer;
begin
AList := LockList;
try
for I := AList.Count - 1 downto 0 do
begin
Item := AList.Items[I];
//AList.Remove(Item);
Dispose(Item);
end;
finally
UnlockList;
end;
inherited;
end;

function TTaskList.GetItems(Index: Integer): TTaskRecord;
var
AList: TList;
begin
AList := LockList;
try
Result := TTaskRecord(AList.Items[Index]^);
finally
UnlockList;
end;
end;

procedure TTaskList.SetItems(Index: Integer; const Value: TTaskRecord);
var
AList: TList;
begin
AList := LockList;
try
TTaskRecord(AList.Items[Index]^) := Value;
finally
UnlockList;
end;
end;

{ Important: Methods and properties of objects in VCL or CLX can only be used
in a method called using Synchronize, for example,

Synchronize(UpdateCaption);

and UpdateCaption could look like,

procedure TTaskThread.UpdateCaption;
begin
Form1.Caption := ＇＇Updated in a thread＇＇;

end; }

procedure TTaskList.TaskCommand(Index: Integer; Command: TTaskCommandd);
var
AList: TList;
Item: PTaskRecord;
begin
AList := LockList;
try
Item := AList.Items[Index];
Item.Command := Command;
finally
UnlockList;
end;
end;

{ TTaskThread }

procedure TTaskThread.CheckTask;
var
AList: TList;
I: Integer;
ATask: PTaskRecord;
begin
if Assigned(FCurTask) then
begin
if FRunTimes >= FCurTask.Time then
begin
FTaskList.LockList;
try
FCurTask.Status := tsFinished;
FCurTask.DoneTimes := FRunTimes;
finally
FTaskList.UnlockList;
end;
FCurTask := nil;
end
else if FCurTask.Command = tcStop then
begin
FTaskList.LockList;
try
FCurTask.Status := tsWaiting;
finally
FTaskList.UnlockList;
end;
FCurTask := nil;
end
else if FCurTask.Command = tcPause then
begin
FTaskList.LockList;
try
FCurTask.Status := tsPause;
finally
FTaskList.UnlockList;
end;
FCurTask := nil;
end;
end;

if not Assigned(FCurTask) then
begin
FRunTimes := 0;
AList := FTaskList.LockList;
try
for I := 0 to AList.Count - 1 do
begin
ATask := AList.Items[I];
case ATask.Status of
tsWaiting:
begin
FCurTask := ATask;
FCurTask.Status := tsRunning;
end;
tsPause:
if ATask.Command = tcRun then
begin
FCurTask := ATask;
FRunTimes := ATask.DoneTimes;
FCurTask.Command := tcNone;
FCurTask.Status := tsRunning;
end;
end;
if Assigned(FCurTask) then
Break;
end;
finally
FTaskList.UnlockList;
end;
end;

if Assigned(FCurTask) then
while Suspended do
Resume;
end;

constructor TTaskThread.Create(TaskList: TTaskList);
begin
inherited Create(True);
FTaskList := TaskList;
end;

procedure TTaskThread.Execute;
begin
{ Place thread code here }
CheckTask;
while not TaskFinished and not Terminated do
begin
Inc(FRunTimes);

FTaskList.LockList;
try
FCurTask.DoneTimes := FRunTimes;
finally
FTaskList.UnlockList;
end;

Sleep(10);
end;
Suspend;
end;

function TTaskThread.GetTaskFinished: Boolean;
begin
CheckTask;
Result := not Assigned(FCurTask);
end;

end.

22楼: 帮顶!

http://www.source520.com

站长开发推广同盟站长朋友的终极驿站
同时拥有海量源码电子经典书籍下载

http://www.source520.com/search/search.asp

＂编程.站长＂论坛搜索引擎-----为中国站长注入动力! 如医药进销存管理软件

联系我们

财务软件使用常见问题

进销存财务管理软件常见问题

仓库管理软件论坛精华

销售管理软件论坛精华

进销存软件精彩推荐

如何将DBGrid的标题栏变

急求一个复杂报表控件

freelibrary 的问题找

关于向Decimal类型字段

实在不敢相信，borland