我试图在循环中调用一个方法。它应该在 10 秒内只调用 20 次。 我正在使用如下代码所示的信号量

Question

By using the below code firstly some of the calls are not getting made lets say out of 250 , 238 calls are made and rest doesn't.Secondly I am not sure if the calls are made at the rate of 20 calls per 10 seconds.

public List<ShowData> GetAllShowAndTheirCast()
    {
        ShowResponse allShows = GetAllShows();

        ShowCasts showCast = new ShowCasts();
        showCast.showCastList = new List<ShowData>();


        using (Semaphore pool = new Semaphore(20, 20))
        {
            for (int i = 0; i < allShows.Shows.Length; i++)
            {
                pool.WaitOne();
                Thread t = new Thread(new ParameterizedThreadStart((taskId) =>
                {
                 showCast.showCastList.Add(MapResponse(allShows.Shows[i]));
                }));
                pool.Release();
                t.Start(i);
            }
        }
        //for (int i = 0; i < allShows.Shows.Length; i++)
        //{
        //    showCast.showCastList.Add(MapResponse(allShows.Shows[i]));
        //}

        return showCast.showCastList;
    }

 public ShowData MapResponse(Show s)
    {
        CastResponse castres = new CastResponse();
        castres.CastlistResponse = (GetShowCast(s.id)).CastlistResponse;
        ShowData sd = new ShowData();
        sd.id = s.id;
        sd.name = s.name;
        if (castres.CastlistResponse != null && castres.CastlistResponse.Any())
        {

            sd.cast = new List<CastData>();
            foreach (var item in castres.CastlistResponse)
            {
                CastData cd = new CastData();
                cd.birthday = item.person.birthday;
                cd.id = item.person.id;
                cd.name = item.person.name;
                sd.cast.Add(cd);
            }

        }
        return sd;
    }
public ShowResponse GetAllShows()
    {
        ShowResponse response = new ShowResponse();
        string showUrl = ClientAPIUtils.apiUrl + "shows";
        response.Shows = JsonConvert.DeserializeObject<Show[]>(ClientAPIUtils.GetDataFromUrl(showUrl));
        return response;
    }

    public CastResponse GetShowCast(int showid)
    {
        CastResponse res = new CastResponse();
        string castUrl = ClientAPIUtils.apiUrl + "shows/" + showid + "/cast";
        res.CastlistResponse = JsonConvert.DeserializeObject<List<Cast>>(ClientAPIUtils.GetDataFromUrl(castUrl));
        return res;
    }

All the Calls should be made , but I am not sure where they are getting aborted and even please let me know how to check the rate of calls being made.

Answer 1

I'm assuming that your goal is to process all data about shows but no more than 20 at once. For that kind of task you should probably use ThreadPool and limit maximum number of concurrent threads using SetMaxThreads .

https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool?view=netframework-4.7.2

You have to make sure that collection that you are using to store your results is thread-safe.

showCast.showCastList = new List<ShowData>();

I don't think that standard List is thread-safe. Thread-safe collection is ConcurrentBag (there are others as well). You can make standard list thread-safe but it requires more code. After you are done processing and need to have results in list or array you can convert collection to desired type.

https://docs.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentbag-1?view=netframework-4.7.2

Now to usage of semaphore. What your semaphore is doing is ensuring that maximum 20 threads can be created at once. Assuming that this loop runs in your app main thread your semaphore has no purpose. To make it work you need to release semaphore once thread is completed; but you are calling thread Start() after calling Release() . That results in thread being executed outside "critical area".

using (Semaphore pool = new Semaphore(20, 20)) {
    for (int i = 0; i < allShows.Shows.Length; i++) {
        pool.WaitOne();
        Thread t = new Thread(new ParameterizedThreadStart((taskId) =>
        {
            showCast.showCastList.Add(MapResponse(allShows.Shows[i]));
            pool.Release();
        }));            
        t.Start(i);
    }
}

I did not test this solution; additional problems might arise.

Another issue with this program is that it does not wait for all threads to complete. Once all threads are started; program will end. It is possible (and in your case I'm sure) that not all threads completed its operation; this is why ~240 data packets are done when program finishes.

thread.Join();

But if called right after Start() it will stop main thread until it is completed so to keep program concurrent you need to create a list of threads and Join() them at the end of program. It is not the best solution. How to wait on all threads that program can add to ThreadPool

Wait until all threads finished their work in ThreadPool

As final note you cannot access loop counter like that. Final value of loop counter is evaluated later and with test I ran; code has tendency to process odd records twice and skip even. This is happening because loop increases counter before previous thread is executed and causes to access elements outside bounds of array.

Possible solution to that is to create method that will create thread. Having it in separate method will evaluate allShows.Shows[i] to show before next loop pass.

public void CreateAndStartThread(Show show, Semaphore pool, ShowCasts showCast)
{
        pool.WaitOne();
        Thread t = new Thread(new ParameterizedThreadStart((s) => {
            showCast.showCastList.Add(MapResponse((Show)s));
            pool.Release();
        }));
    t.Start(show);
}

Concurrent programming is tricky and I would highly recommend to do some exercises with examples on common pitfalls. Books on C# programming are sure to have a chapter or two on the topic. There are plenty of online courses and tutorials on this topic to learn from.

Edit: Working solution. Still might have some issues.

    public ShowCasts GetAllShowAndTheirCast()
        {
            ShowResponse allShows = GetAllShows();

            ConcurrentBag<ShowData> result = new ConcurrentBag<ShowData>();
            using (var countdownEvent = new CountdownEvent(allShows.Shows.Length))
            {
                using (Semaphore pool = new Semaphore(20, 20))
                {
                    for (int i = 0; i < allShows.Shows.Length; i++)
                    {
                        CreateAndStartThread(allShows.Shows[i], pool, result, countdownEvent);
                    }

                    countdownEvent.Wait();
                }     
            }
            return new ShowCasts() { showCastList = result.ToList() };
        }

    public void CreateAndStartThread(Show show, Semaphore pool, ConcurrentBag<ShowData> result, CountdownEvent countdownEvent)
        {
            pool.WaitOne();
            Thread t = new Thread(new ParameterizedThreadStart((s) =>
            {
                result.Add(MapResponse((Show)s));
                pool.Release();
                countdownEvent.Signal();
            }));

            t.Start(show);
        }