Вопрос по multithreading, wcf – Имеет ли ConcurrencyMode of Multiple актуальность, когда InstanceContextMode является PerCall для службы WCF с привязкой Net.Tcp?

10

Я всегда думал, что установка InstanceContextMode в PerCall делает режим параллелизма нерелевантным, даже если используется привязка, учитывающая сеанс, как net.tcp. Это то, что говорит MSDN http://msdn.microsoft.com/en-us/library/ms731193.aspx & quot; В PerCallinstancing параллелизм не имеет значения, поскольку каждое сообщение обрабатывается новым InstanceContext и, следовательно, в InstanceContext никогда не активируется более одного потока. & quot;


Но сегодня я просматривал книгу Ювала Лоуи «Программирование служб WCF», и он пишет в главе 8

If the per-call service has a transport-level session, whether concurrent processing of calls is allowed is a product of the service concurrency mode. If the service is configured with ConcurrencyMode.Single, concurrent processing of the pending calls is not al lowed, and the calls are dispatched one at a time. [...] I consider this to be a flawed design. If the service is configured with ConcurrencyMode.Multiple, concurrent pro- cessing is allowed. Calls are dispatched as they arrive, each to a new instance, and execute concurrently. An interesting observation here is that in the interest of through- put, it is a good idea to configure a per-call service with ConcurrencyMode.Multiple— the instance itself will still be thread-safe (so you will not incur the synchronization liability), yet you will allow concurrent calls from the same client.


Это противоречит моему пониманию и тому, что говорит MSDN. Что правильно ? В моем случае у меня есть служба WCF Net.Tcp, которая использовала мои многочисленные клиентские приложения, которые создают новый объект прокси, совершают вызов, а затем немедленно закрывают прокси. Служба имеет PerCall InstanceContextMode. Получу ли я улучшенную пропускную способность, если я изменю InstanceContextMode на Multiple с безопасным поведением потока не хуже, чем percall?

Отличный вопрос. Рассматривали ли вы создание этого в консольном приложении и тестирование, чтобы увидеть? tom redfern

Ваш Ответ

1   ответ
8

Ключевая фраза в чтении высказывания Лоуи: & # x201C;in the interest of throughput& # X201D ;. Лоуи указывает, что при использовании ConcurrencyMode.Single WCF слепо реализует блокировку для принудительной сериализации для экземпляра службы. Блокировки дороги, и в этом нет необходимости, потому что PerCall уже гарантирует, что второй поток никогда не будет пытаться вызвать тот же экземпляр службы.

In terms of behavior: ConcurrencyMode не имеет значения для экземпляра службы PerCall.

In terms of performance: A PerCall service that is ConcurrencyMode.Multiple should be slightly faster because its not creating and acquiring the (unneeded) thread lock that ConcurrencyMode.Single is using.

Я написал программу для быстрого тестирования, чтобы узнать, смогу ли я измерить влияние на производительность Single vs Multiple для службы PerCall:The benchmark showed no meaningful difference.

Я вставил код ниже, если вы хотите попробовать запустить его самостоятельно.

Test cases I tried:

  • 600 threads calling a service 500 times
  • 200 threads calling a service 1000 times
  • 8 threads calling a service 10000 times
  • 1 thread calling a service 10000 times

Я запустил это на 4-х процессорной виртуальной машине под управлением Service 2008 R2. Все, кроме случая с 1 потоком, были ограничены ЦП.

Results: All the runs were within about 5% of eachother. Sometimes ConcurrencyMode.Multiple was faster. Sometimes ConcurrencyMode.Single was faster. Maybe a proper statistical analysis could pick a winner. In my opinion they are close enough to not matter.

Вот типичный вывод:

началоSingle Service on net.pipe://localhost/base... Type=SingleService ThreadCount=600 ThreadCallCount=500 runtime: 45156759 ticks   12615 мсек

началоMultiple Service on net.pipe://localhost/base... Type=MultipleService ThreadCount=600 ThreadCallCount=500 runtime: 48731273 ticks   13613 мсек

началоSingle Service on net.pipe://localhost/base... Type=SingleService ThreadCount=600 ThreadCallCount=500 runtime: 48701509 ticks   13605 мсек

началоMultiple Service on net.pipe://localhost/base... Type=MultipleService ThreadCount=600 ThreadCallCount=500 runtime: 48590336 ticks   13574 мсек

Benchmark Code:

Обычное предостережение: это эталонный код, который использует короткие пути, которые не подходят для производственного использования.

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace WCFTest
{
    [ServiceContract]
    public interface ISimple
    {
        [OperationContract()]
        void Put();
    }

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
    public class SingleService : ISimple
    {
        public void Put()
        {
            //Console.WriteLine("put got " + i);
            return;
        }
    }

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class MultipleService : ISimple
    {
        public void Put()
        {
            //Console.WriteLine("put got " + i);
            return;
        }
    }

    public class ThreadParms
    {
        public int ManagedThreadId { get; set; }
        public ServiceEndpoint ServiceEndpoint { get; set; }
    }

    public class BenchmarkService
    {
        public readonly int ThreadCount;
        public readonly int ThreadCallCount;
        public readonly Type ServiceType; 

        int _completed = 0;
        System.Diagnostics.Stopwatch _stopWatch;
        EventWaitHandle _waitHandle;
        bool _done;

        public BenchmarkService(Type serviceType, int threadCount, int threadCallCount)
        {
            this.ServiceType = serviceType;
            this.ThreadCount = threadCount;
            this.ThreadCallCount = threadCallCount;

            _done = false;
        }

        public void Run(string baseAddress)
        {
            if (_done)
                throw new InvalidOperationException("Can't run twice");

            ServiceHost host = new ServiceHost(ServiceType, new Uri(baseAddress));
            host.Open();

            Console.WriteLine("Starting " + ServiceType.Name + " on " + baseAddress + "...");

            _waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
            _completed = 0;
            _stopWatch = System.Diagnostics.Stopwatch.StartNew();

            ServiceEndpoint endpoint = host.Description.Endpoints.Find(typeof(ISimple));

            for (int i = 1; i <= ThreadCount; i++)
            {
                // ServiceEndpoint is NOT thread safe. Make a copy for each thread.
                ServiceEndpoint temp = new ServiceEndpoint(endpoint.Contract, endpoint.Binding, endpoint.Address);
                ThreadPool.QueueUserWorkItem(new WaitCallback(CallServiceManyTimes),
                    new ThreadParms() { ManagedThreadId = i, ServiceEndpoint = temp });
            }

            _waitHandle.WaitOne();
            host.Shutdown();

            _done = true;

            //Console.WriteLine("All DONE.");
            Console.WriteLine("    Type=" + ServiceType.Name + "  ThreadCount=" + ThreadCount + "  ThreadCallCount=" + ThreadCallCount);
            Console.WriteLine("    runtime: " + _stopWatch.ElapsedTicks + " ticks   " + _stopWatch.ElapsedMilliseconds + " msec");
        }

        public void CallServiceManyTimes(object threadParams)
        {
            ThreadParms p = (ThreadParms)threadParams;

            ChannelFactory<ISimple> factory = new ChannelFactory<ISimple>(p.ServiceEndpoint);
            ISimple proxy = factory.CreateChannel();

            for (int i = 1; i < ThreadCallCount; i++)
            {
                proxy.Put();
            }

            ((ICommunicationObject)proxy).Shutdown();
            factory.Shutdown();

            int currentCompleted = Interlocked.Increment(ref _completed);

            if (currentCompleted == ThreadCount)
            {
                _stopWatch.Stop();
                _waitHandle.Set();
            }
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            BenchmarkService benchmark;
            int threadCount = 600;
            int threadCalls = 500;
            string baseAddress = "net.pipe://localhost/base";

            for (int i = 0; i <= 4; i++)
            {
                benchmark = new BenchmarkService(typeof(SingleService), threadCount, threadCalls);
                benchmark.Run(baseAddress);

                benchmark = new BenchmarkService(typeof(MultipleService), threadCount, threadCalls);
                benchmark.Run(baseAddress);
            }

            baseAddress = "http://localhost/base";

            for (int i = 0; i <= 4; i++)
            {
                benchmark = new BenchmarkService(typeof(SingleService), threadCount, threadCalls);
                benchmark.Run(baseAddress);

                benchmark = new BenchmarkService(typeof(MultipleService), threadCount, threadCalls);
                benchmark.Run(baseAddress);
            }

            Console.WriteLine("Press ENTER to close.");
            Console.ReadLine();

        }
    }

    public static class Extensions
    {
        static public void Shutdown(this ICommunicationObject obj)
        {
            try
            {
                if (obj != null)
                    obj.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Shutdown exception: {0}", ex.Message);
                obj.Abort();
            }
        }
    }
}
Спасибо, что подтверждает мои мысли. По крайней мере, нет ничего плохого в том, чтобы установить для ConcurrencyMode значение Multiple. softveda

Похожие вопросы