标签: threadpool

我试图找到一种从一堆线程中记录有用上下文的方法.问题是很多代码都是通过线程池线程到达的事件处理的(据我所知),因此它们的名称与任何上下文无关.可以使用以下代码演示此问题:

class Program
{
    private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
    static void Main(string[] args)
    {
        new Thread(TestThis).Start("ThreadA");
        new Thread(TestThis).Start("ThreadB");
        Console.ReadLine();
    }

    private static void TestThis(object name)
    {
        var nameStr = (string)name;
        Thread.CurrentThread.Name = nameStr;
        log4net.ThreadContext.Properties["ThreadContext"] = nameStr;
        log4net.LogicalThreadContext.Properties["LogicalThreadContext"] = nameStr;
        log.Debug("From Thread itself");
        ThreadPool.QueueUserWorkItem(x => log.Debug("From threadpool Thread: " + nameStr));
    }
}

转换模式是:

%date [%thread] %-5level %logger [%property] - %message%newline

输出是这样的:

2010-05-21 15:08:02,357 [ThreadA] DEBUG LogicalContextTest.Program [{LogicalThreadContext=ThreadA, log4net:HostName=xxx, ThreadContext=ThreadA}] - From Thread itself
2010-05-21 15:08:02,357 [ThreadB] DEBUG LogicalContextTest.Program …

我有一个在Sun 1.6 32位VM/Solaris 10(x86)/ Nahelem 8核(每个核心2个线程)上运行的Java应用程序.

应用程序中的特定用例是响应某些外部消息.在我的性能测试环境中,当我准备并在接收外部输入的同一线程中发送响应时,我获得大约50美元的优势,而不是当我将消息传递给单独的线程来发送响应时.我使用的是ThreadPoolExecutor用SynchronousQueue做切换.

在你的经历中是什么 接受将任务调度到线程池并将其拾取执行之间的预期延迟？过去有什么想法可以改善这一点？

ForkJoinPool的异步模式是什么意思？Javadoc提到它使队列(它是每线程队列吗？)FIFO而不是LIFO.这在实践中意味着什么？

令人沮丧的是,HawtDispatch的网站将其描述为"线程池和NIO事件通知框架API".

我们先来看一下'线程池'部分.Java提供的大多数Exec​​utor也基本上都是线程池.HawtDispatch有何不同？

它显然也是一个"NIO事件通知框架API".我假设它是顶层NIO上的一个薄层,它接收传入数据并传递给它的"线程池"概念,并在线程池调度程序找到时间时将其传递给使用者.正确？(欢迎对NIO进行任何改进).有没有人对netty和HD做过任何性能分析？

我有许多优先传入的任务A,B并且C我想在多核CPU上使用线程池处理任务.70%的CPU应该用于处理"类型A"任务,20%的CPU用于"类型B"任务,10%用于"类型C"任务.

但是,如果只有'type C'的任务到达,那么100%的CPU应该专门用于它们.如果只有任务B和Carirve那么66%将完成任务B和33%任务C等...

你会如何在Java中实现它？

ps:优先级队列不起作用,因为那时只会处理任务类型.此外,为线程分配优先级不会起作用,因为它不准确.

由于这个错误,我一直在阅读和测试并在墙上撞了一天多一天.

我在类中有一些Java代码Listener,看起来像这样

ExecutorService executor = Executors.newFixedThreadPool(NTHREADS);
boolean listening = true;
int count = 0;
while (listening) {
    Runnable worker;
    try {
        worker = new ServerThread(serverSocket.accept()); // this is line 254
        executor.execute(worker);
        count++;
        logger.info("{} threads started", count);
    } catch (Exception e1){
        //...
    }
}

我一直在调整JVM设置-Xmx(从1到15G -Xss不等)和(从104k到512M).服务器有24 GB的RAM,但还必须运行支持该程序的数据库.

在创建了2-20个线程之后(程序中的其他地方也存在了几十个),我得到了错误

Exception in thread "Thread-0" java.lang.OutOfMemoryError: unable to create new native thread
at java.lang.Thread.start0(Native Method)
at java.lang.Thread.start(Thread.java:657)
at java.util.concurrent.ThreadPoolExecutor.addWorker(ThreadPoolExecutor.java:943)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1325)
at xxx.Listener.run(Listener.java:254)

$java -version 收益率:

java version "1.6.0_24" …

我是多线程的新手,我正在开发一个项目,我试图在我的Java程序中使用4个CPU.我想做点什么

int numProcessors = Runtime.getRuntime().availableProcessors();
ExecutorService e = Executors.newFixedThreadPool(numProcessors);

这可以保证每个CPU都有一个线程工作吗？在我创建线程时,系统不会很忙,但是一段时间后它会非常繁忙.我认为操作系统会选择最不繁忙的CPU来创建线程,但是如果它们在创建时没有特别繁忙的话它是如何工作的呢？

此外,线程池服务应该重用线程,但如果它看到另一个CPU上有更多的可用性,它会杀死线程并在那里产生一个新线程吗？

我有一个创建多个任务的循环,如下所示.每个任务完成后,如何更新屏幕(使用某些数据向文本框添加新行)？

如何检测所有任务何时完成？

C#代码

 for (int i = 0; i < int.Parse(radTextBoxFloodRequests.Text); i++)
 {
      int x = i;
      // Create a task and supply a user delegate by using a lambda expression. 
      var taskA = new Task(() => TaskRequest(int.Parse(radTextBoxFirstNumber.Text), int.Parse(radTextBoxSecondNumber.Text), int.Parse(radTextBoxFloodDelay.Text), x));
      // Start the task.
      taskA.Start();
 }


 private void TaskRequest(int number1, int number2, int delay, int count)
 {
      // Some long running method
 }

我们正在使用Glassfish 3.0.1,并且经历了很长的响应时间; 对于25%的POST/PUT请求,大约5分钟,当响应返回时,前置负载平衡器已经超时.

我的理论是请求排队并等待可用的线程.

我认为这是因为访问日志显示请求需要几秒钟才能完成,但请求执行的时间比我预期的晚了五分钟.

有没有人对调试线程池的内容有任何建议？或者他们的最佳设置是什么？

是否需要定期进行线程转储,或者一次性转储是否足够？

我有一个简单的客户端应用程序,它以低吞吐量从网络接收字节缓冲区.这是代码:

private static readonly HashSet<int> _capturedThreadIds = new HashSet<int>();

private static void RunClient(Socket socket)
{
    var e = new SocketAsyncEventArgs();
    e.SetBuffer(new byte[10000], 0, 10000);
    e.Completed += SocketAsyncEventsArgsCompleted;

    Receive(socket, e);
}

private static void Receive(Socket socket, SocketAsyncEventArgs e)
{
    var isAsynchronous = socket.ReceiveAsync(e);
    if (!isAsynchronous)
        SocketAsyncEventsArgsCompleted(socket, e);
}

private static void SocketAsyncEventsArgsCompleted(object sender, SocketAsyncEventArgs e)
{
    if (e.LastOperation != SocketAsyncOperation.Receive || e.SocketError != SocketError.Success || e.BytesTransferred <= 0)
    {
        Console.WriteLine("Operation: {0}, Error: {1}, BytesTransferred: {2}", e.LastOperation, e.SocketError, e.BytesTransferred);
        return;
    }

    var …