【WCF】a bunch of concurrent clients！-优快云博客

本文探讨了通过调整WCF服务中ListenBacklog参数来提高服务处理并发请求的能力及稳定性。默认设置下，ListenBacklog与MaxConcurrentCalls等参数均为10，通过增大ListenBacklog值可以有效缓冲待处理消息，使服务更加稳定。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原帖地址:http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=1755618&SiteID=1

There's an additional setting on the binding that you would need to increase. It's the ListenBacklog. I think if you make this greater than or equal to your MaxConcurrentCalls, the service will be more stable.

By default, all the throttling behaviors (MaxConcurrentCalls/Instances/Sessions) are set to 10. The ListenBacklog is set to 10 by default, too. The ListenBacklog defines how many messages to "buffer" while the service tries to dispatch other messages. So, if you set all the throttling behaviors to something like 5 and set ListenBacklog to something greater than the number of clients you plan to connect, you could still process a bunch of concurrent clients, provided they close their channels after sending the messages. For reference, here's the code I was working with to understand this:

Code Snippet
using System;

using System.Collections.Generic;

using System.Text;

using System.ServiceModel;

using System.ServiceModel.Description;

using System.Threading;

using System.ServiceModel.Channels;

namespace LotsOfChannels

{

class Program

{

static void Main(string[] args)

{

try

{

// channelsToOpen determines how many concurrent threads will be started.

int channelsToOpen = 20;

string address = "net.tcp://localhost/service";

NetTcpBinding binding = new NetTcpBinding("mathTCPBindingConf");

binding.ListenBacklog = 10;

ServiceHost host = new ServiceHost(typeof(HelloService), new Uri(address));

host.AddServiceEndpoint(typeof(IHelloContract), binding, address);

// I think that ListenBacklog + MaxConcurrentCalls > channelsToOpen. 

// Okay, maybe that's not entirely true, because it doesn't count the messages that have already been dispatched. Maybe a better way to test this is to have the service method just sleep. Then I can count the number of calls waiting/buffered/hanging/etc.

// The most reliable thing I've found is that ListenBackLog >= MaxConcurrentCalls generates more stable services.

ServiceThrottlingBehavior throttling = new ServiceThrottlingBehavior();

throttling.MaxConcurrentCalls = 10;

throttling.MaxConcurrentInstances = 5;

throttling.MaxConcurrentSessions = 5;

ServiceDescription des = host.Description;

des.Behaviors.Add(throttling);

host.Open();

// Now connect clients concurrently:

Thread[] channelThreads = new Thread[channelsToOpen];

for (int i = 0; i < channelsToOpen; ++i)

{

channelThreads[i] = new Thread(new ParameterizedThreadStart(SendMessageOnChannel));

channelThreads[i].Name = "Thread #" + i;

}

for (int i = 0; i < channelsToOpen; ++i)

{

ChannelFactory<IHelloContract> factory = new ChannelFactory<IHelloContract>(binding, address);

IHelloContract channel = factory.CreateChannel();

channelThreads[i].Start((Object)channel);

}

Console.WriteLine("Done.");

}

catch (Exception e)

{

Console.WriteLine(e);

}

Console.ReadLine();

}

public static void SendMessageOnChannel(Object channel)

{

try

{

Console.WriteLine("Sending message on {0}", Thread.CurrentThread.Name);

((IHelloContract)channel).Hello(Thread.CurrentThread.Name);

((IChannel)(IHelloContract)channel).Close();

}

catch (Exception e)

{

Console.WriteLine(e);

}

}

}

[ServiceContract]

public interface IHelloContract

{

[OperationContract]

void Hello(string name);

}

public class HelloService : IHelloContract

{

public void Hello(string name)

{

Console.WriteLine("[Service]: Hello. Received from thread {0}", name);

}

}

}

The App.config file just has the binding you used

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

<system.serviceModel>

<bindings>

<netTcpBinding>

<binding name="mathTCPBindingConf" 

closeTimeout="00:00:10" 

openTimeout="00:10:00"

receiveTimeout="00:10:00" 

sendTimeout="00:10:00" 

maxConnections="500" 

maxBufferSize="104857600" 

maxReceivedMessageSize="104857600">

<security mode="None" />

<readerQuotas maxDepth="2147483647"

maxStringContentLength="2147483647"

maxArrayLength="2147483647"

maxBytesPerRead="2147483647"

maxNameTableCharCount="2147483647" />

</binding>

</netTcpBinding>

</bindings>

<behaviors>

<serviceBehaviors>

<behavior name="MathServiceBehaviours" >

<serviceThrottling

maxConcurrentCalls="100"

maxConcurrentSessions="100"

maxConcurrentInstances="100"

/>

</behavior>

</serviceBehaviors>

</behaviors>

</system.serviceModel>

</configuration>