标签: threadpool

Environment: Windows Server 2008 Enterprise, IIS 7.0, ASP.NET 2.0 (CLR), .NET 4.0

我有一个ASP.NET没有页面和没有session(HttpHandler)的应用程序.它是流媒体服务器.我使用两个线程来处理每个请求,因此如果有100个连接的客户端,则使用200个线程.这是一个专用服务器,服务器上没有更多应用程序.

问题是200个客户端连接后(在压力测试下)应用程序拒绝新客户端,但如果我增加application pool(创建一个Web园)的工作线程,那么每个w3wp进程可以有200个新的快乐客户端.

我觉得.NET线程池限制达到了那个点,需要增加它.

谢谢

什么时候抛出InvalidAsynchronousStateException？

我有以下代码:

control.InvokeRequired？control.Invoke(expression):expression();

在一些随机的情况下,我得到InvalidAsynchronousStateException并且我的应用程序挂起,在做了一些阅读之后,似乎是当control创建的线程完成时将抛出此异常.它是否正确？如果是这样的话,情况似乎并非如此,除非某些事情导致我的应用程序崩溃,这种异常只是后果吗？这可能吗？

System.ComponentModel.InvalidAsynchronousStateException:调用方法时发生错误.目标线程不再存在.在System.Windows.Forms.Control.WaitForWaitHandle(WaitHandle的WaitHandle的)在System.Windows.Forms.Control.MarshaledInvoke在System.Windows.Forms.Control.Invoke(控制呼叫者,委派方法,对象[]指定参数时,布尔同步)(委托方法,在Optimus.Desktop.Framework.Spring.Aspects.UIThreadInterceptor.Invoke(IMethodInvocation调用在c)中对象[]在System.Windows.Forms.Control.Invoke(委托方法)参数):\的Optimus \桌面\框架\春\ \方面UIThreadInterceptor.cs:在Spring.Aop.Framework.AbstractMethodInvocation.Proceed()在Spring.Aop.Framework.DynamicProxy.AdvisedProxy.Invoke(对象代理,对象目标,类型目标类型,MethodInfo的targetMethod,MethodInfo的proxyMethod线22,在InheritanceAopProxy_4fda07e8828744839065a154b30915ee.Dispose(布尔处置)在System.ComponentModel.Component.Finalize对象[]指定参数时,IList的拦截器)()

顺便说一句,我已经检查了这个答案并没有澄清我的疑问 - > 函数中的InvalidAsynchronousStateException检查控件是否需要调用

在阅读了关于Node的线程性质的这个很好的答案后,我开始使用UV_THREADPOOL_SIZE系统变量来改变线程池的大小,我发现了一些有趣的东西:

当我设置

process.env.UV_THREADPOOL_SIZE = 10;

我的Node进程中有15个线程(我认为它应该是10 + 1主节点线程= 11).

看看我的剧本:

process.env.UV_THREADPOOL_SIZE = 10;

//init thread pool by calling `readFile` function
require('fs').readFile(__filename, 'utf8', function(err, content) {});

//make node not exiting
setInterval(function() {}, 1000);

运行后我输入:

ps -Lef | grep test.js | grep -v grep

并获得以下结果:

olegssh   4869  4301  4869  0   15 16:38 pts/0    00:00:00 /home/olegssh/node/bin/node test.js
olegssh   4869  4301  4870  0   15 16:38 pts/0    00:00:00 /home/olegssh/node/bin/node test.js
olegssh   4869  4301  4871  0   15 16:38 pts/0    00:00:00 …

我刚刚开始研究Java的Executors类和newCachedThreadPool( )方法.根据API,生成的线程池会Thread为新任务重用现有对象.

我有点疑惑它是如何实现的,因为我在ThreadAPI中找不到任何允许您设置现有Thread对象行为的方法.

例如,您可以创建一个新的 Thread从一个Runnable对象,这使得Thread调用Runnable的run( )方法.但是,ThreadAPI中没有以set Runnable作为参数的setter方法.

我很感激任何指针.

我有一个工作队列,我想建立一个4个线程的池,我可以把我的工作.我所坚持的是如何制作线程并在没有工作的情况下让它们暂停.

JOB QUEUE        | job1 | job2 | job3 | job4 | ..

THREAD POOL      | thread1 | thread2 | thread3 | thread4 |

要创建我目前处于初始化点的线程:

for (t=0; t<num_of_threads; t++){
    pthread_create(&(threads[t]), NULL, doSth2, NULL);
}

num_of_threads = 4且doSth2是一个内部没有任何内容的函数.所以一旦我创建了4个线程并且完成了doSth2,我怎么能给他们新的工作呢,而不会杀死他们？

我正在开发一个控制台应用程序

我想使用Threadpool来执行Web下载.这是一些假代码.

 for (int loop=0; loop< 100; loop++)
 {
     ThreadPool.QueueUserWorkItem(new WaitCallback(GetPage), pageList[loop]);
 }


snip

private static void GetPage(object o)
{
    //get the page
}

如何防止我的代码启动两个以上(或十个或其他)同步线程？

我试过了

    ThreadPool.SetMaxThreads(1, 0);
    ThreadPool.SetMinThreads(1, 0);

但他们似乎没有任何影响.

我编写了一个脚本,它使用两个线程池,每个线程池包含10个线程,用于从API中提取数据.线程池在ActiveState上实现此代码.每个线程池都通过PubSub监视Redis数据库以获取新条目.当一个新的条目将被发布,蟒蛇将数据传递到使用Python的功能Subprocess.POpen执行PHP壳里做调用API的实际工作.

这个启动PHP shell的系统对于我的PHP Web应用程序的功能是必需的,因此无法避免使用Python启动PHP shell.

此脚本仅在Linux服务器上运行.

如何控制应用程序线程的niceness(调度优先级)？

编辑:

似乎无法控制Python中各个线程的调度优先级.有一个python解决方案,或者至少是一个UNIX命令,我可以与我的脚本一起运行,以控制优先级？

编辑2:

好吧,我最终没有找到一种python方式来处理它.我现在正好运行我的脚本,就像这样:

nice -n 19 python MyScript.py

我正在尝试使用boost :: asio创建一个有限的线程池类.但是我被困在某一点可以帮助我.

唯一的问题是我应该减少反击的地方？

代码无法按预期工作.

问题是我不知道我的线程何时完成执行以及我将如何知道它已经返回池中

#include <boost/asio.hpp>
#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/thread/mutex.hpp>
#include <stack>

using namespace std;
using namespace boost;

class ThreadPool
{
    static int count;
    int NoOfThread;
    thread_group grp;
    mutex mutex_;
    asio::io_service io_service;
    int counter;
    stack<thread*> thStk ;

public:
    ThreadPool(int num)
    {   
        NoOfThread = num;
        counter = 0;
        mutex::scoped_lock lock(mutex_);

        if(count == 0)
            count++;
        else
            return;

        for(int i=0 ; i<num ; ++i)
        {
            thStk.push(grp.create_thread(boost::bind(&asio::io_service::run, &io_service)));
        }
    }
    ~ThreadPool()
    {
        io_service.stop();
        grp.join_all();
    }

    thread* getThread()
    { …

我正在使用同步apis和线程池的tcp服务器上看起来像这样:

TcpListener listener;
void Serve(){
  while(true){
    var client = listener.AcceptTcpClient();
    ThreadPool.QueueUserWorkItem(this.HandleConnection, client);
    //Or alternatively new Thread(HandleConnection).Start(client)
  }
}

假设我的目标是在资源使用率最低的情况下处理尽可能多的并发连接,这似乎很快就会受到可用线程数量的限制.我怀疑通过使用非阻塞任务apis,我将能够用更少的资源处理更多.

我最初的印象是这样的:

async Task Serve(){
  while(true){
    var client = await listener.AcceptTcpClientAsync();
    HandleConnectionAsync(client); //fire and forget?
  }
}

但令我印象深刻的是,这可能会导致瓶颈.也许HandleConnectionAsync需要花费非常长的时间才能达到第一次等待,并且将阻止主接受循环继续进行.这只会使用一个线程,还是运行时会在多个线程上神奇地运行它看起来合适的东西？

有没有办法结合这两种方法,以便我的服务器将使用它所需的线程数量来确定正在运行的任务的数量,但是它不会在IO操作上不必要地阻塞线程？

在这样的情况下,是否存在最大化吞吐量的惯用方法？

我一直在考虑使用异步编程设置TCP服务器的正确方法是什么.

通常我会为每个传入的请求生成一个线程,但我想做大部分的ThreadPool,所以当连接空闲时,没有被阻塞的线程.

首先,我将创建监听器并开始接受客户端,在本例中,在控制台应用程序中:

static void Main(string[] args)
{
    CancellationTokenSource cancellation = new CancellationTokenSource();
    var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8001);
    TcpListener server = new TcpListener(endpoint); 

    server.Start();
    var task = AcceptTcpClients(server, cancellation.Token);

    Console.ReadKey(true);
    cancellation.Cancel();
    await task;
    Console.ReadKey(true);
}

在该方法中,我将循环接受传入的请求并生成一个新的Task来处理连接,因此循环可以返回以接受更多的客户端:

static async Task AcceptTcpClients(TcpListener server, CancellationToken token)
{
    while (!token.IsCancellationRequested)
    {
        var ws = await server.AcceptTcpClientAsync();

        Task.Factory.StartNew(async () =>
        {
            while (ws.IsConnected && !token.IsCancellationRequested)
            {
                String msg = await ws.ReadAsync();
                if (msg != null)
                    await ws.WriteAsync(ProcessResponse(msg));
            }
        }, token);
    }
 }

创建新任务并不一定意味着新线程,但这是正确的方法吗？我是利用ThreadPool还是我还能做什么？

这种方法有潜在的缺陷吗？