标签: threadpool

我有一个处理文件传输的应用程序.在某些情况下,我需要启动一些处理文件的前/后处理可执行文件.

所以事件的顺序(简而言之)就像这样:

1. 工作线程已创建
2. 工作人员意识到需要在开始传输之前启动预处理可执行文件预处理启动,工作人员等待......如果等待时间过长,则不会发生传输,线程应该优雅地完成
3. 文件已转移
4. 工作人员意识到在传输完成后需要启动后处理可执行文件
5. 后期处理启动,工人不在乎等待

基本上,我不关心在传输发生后后进程可执行文件运行多长时间.因此,如果我从一个然后返回池中的线程启动进程,我是否应该预料到任何问题？

//后期过程

        Process process = null;
        ProcessStartInfo psi = new ProcessStartInfo(executable, args);
        psi.UseShellExecute = true;

        try
        {
            process = Process.Start(psi);
            //The pre-process simply calls Process.WaitForExit(timeout value)
            launched = true;
        }
        catch (InvalidOperationException) { }
        catch (ArgumentException) { }
        catch (System.ComponentModel.Win32Exception) { }
        catch (System.IO.FileNotFoundException) { }

我继续在下面的代码中得到一个内存不足的例外,我想知道是否有什么东西可以阻止这种情况发生.

  private static List<string> MyIds { get; set; }
  private static object LockObject { get; set; }
  private static int Counter { get; set; }
  private static readonly NumOfThreads = 5;

  static void Main(string[] args)
  {
      try
      {
          Console.Clear();
          LockObject = new object();
          // Pull id's into memory (A list of around 1 million ids)
          MyIds = _repository.GetIds();
          for (int i = 0; i < NumOfThreads ; i++)
                ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), (object)i);

       }
       catch (Exception ex)
       {
           Console.WriteLine(ex.StackTrace);
       }
   }

   public …

Asp.net 2默认有12个线程

现在Asp.Net 4有5000.我们还需要异步控制器吗？

我知道TPL不一定为并行集中的每个任务创建一个新线程,但是它总是创建至少一个吗？例如:

private void MyFunc()
{
    Task.Factory.StartNew(() =>
    {
        //do something that takes a while   
    });

    DoSomethingTimely();   //is this line guaranteed to be hit immediately?
}

编辑:澄清:是的,我的意思是保证执行的线程MyFunc()不会被用来执行//do something that takes a while.

使用Spring的集成API Quartz,对具有未捕获异常的cron作业有什么影响？由于cronbean/worker线程没有捕获异常,这是否意味着该线程已经死亡并且无法返回到SimpleThreadPool？如果它死了并且没有返回池将意味着SimpleThreadPool将需要创建新线程,如果这样多次发生,从而清空池？

这是堆栈跟踪的示例:

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean$MethodInvokingJob.executeInternal(MethodInvokingJobDetailFactoryBean.java:276) - Invocation of method 'doCronJob' on target class [abc.package.ServiceImpl] failed
java.io.FileNotFoundException: http://www.website.com
    at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1457)
    at abc.package.ServiceImpl.doCronJob(ServiceImpl.java:453)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at org.springframework.util.MethodInvoker.invoke(MethodInvoker.java:283)
    at org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean$MethodInvokingJob.executeInternal(MethodInvokingJobDetailFactoryBean.java:272)
    at org.springframework.scheduling.quartz.QuartzJobBean.execute(QuartzJobBean.java:86)
    at org.quartz.core.JobRunShell.run(JobRunShell.java:208)
    **at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:520)**

我正在编写一个代码,它将创建一系列线程(例如:) Function GetMACAddress(IPAddr as string) as string.每个线程作业将花费不同的执行时间来处理(如果IP没有被任何PC占用并且最终将返回没有有效的MAC地址,则将花费更长的时间).

如何以这样的方式管理和监视每个线程,以便在指定的超时时间(例如Timeout = 100ms)之后仍然可以完成时,我可以随时停止/中止？在我的情况下,我需要从192.168.1.1扫描到192.168.1.255

我应该在这里使用什么样的线程编码架构？

我正在尝试创建一个具有播放列表选项的媒体播放器.当一个负载10-20首歌没有问题.所以我尝试了更苛刻的东西:我试着加载2048首歌曲(我拍了好几首歌并复制了很多次).试图将它们加载到我的媒体播放器中,我的CPU和Ram内存增长了95%以上(只加载了前250首歌曲),有一次我的电脑重启了.所以我试图通过使用不让应用程序接管计算机的东西来减慢操作:如果CPU负载超过85%并且内存负载超过90%(我使用64位),我会停止加载新歌曲操作系统与Windows 8,如果这很重要).它在某种程度上起作用,允许我加载近600首歌曲然后:

A first chance exception of type 'System.InvalidOperationException' occurred in mscorlib.dll
A first chance exception of type 'System.InvalidOperationException' occurred in mscorlib.dll
A first chance exception of type 'System.InvalidOperationException' occurred in mscorlib.dll
A first chance exception of type 'System.InvalidOperationException' occurred in mscorlib.dll
A first chance exception of type 'System.InvalidOperationException' occurred in mscorlib.dll
The thread 'vshost.NotifyLoad' (0x1d0c) has exited with code 0 (0x0).
The thread 'vshost.LoadReference' (0x1e48) has exited with code 0 (0x0).
A first chance exception of type 'System.OutOfMemoryException' occurred …

这可能是一个非常简单的问题,但是在我认为之前我从未使用过线程,最好不要试图完全依靠自己找到最佳解决方案.

我有一个巨大的for循环,几十亿次运行.在每个循环运行中,根据当前index,程序以数字的形式计算最终结果.我只对存储顶部result(或顶部x结果)及其相应的索引感兴趣.

我的问题很简单,在线程中运行此循环的正确方法是什么,因此它使用所有可用的CPU /核心.

int topResultIndex;
double topResult = 0;

for (i=1; i < 1000000000; ++i) {
    double result = // some complicated calculation based on the current index
    if (result > topResult) {
        topResult = result;
        topResultIndex = i;
    }
}

对于每个索引,计算完全独立,不共享资源.topResultIndex并且topResult显然会被每个线程访问.

*更新:Giulio和rolfl的解决方案都很好,也非常相似.只能接受其中一个作为我的答案.

我想在大量数据上运行多线程程序.我通常创建一个可调用(或可运行)的类,并将进程所需的数据传递给类.

public class CallableTrainer implements Callable<PredictorResult> {

   dataType data;

   CallableTrainer( dataType massiveData ) { 
       this.data = massiveData;
   }

   @Override
   public PredictorResult call() throws Exception {
        // do something and return ... 
   }
}

基于上面的实现,我假设总是为每个线程复制'massiveData'(对吗？)如果这是真的,我通过为每个线程复制这些数据来浪费大量内存.有没有办法在线程之间共享数据？

我正在研究一种非常流行的c#代理服务器.在其中有代码如(我故意隐藏代理服务器身份,因为我觉得很难讲故事,如果确实是错误的话).

private void OnConnectionAccepted(TcpClient cl)
{
     ....
     Task.Run(async () =>
            {
               await HandleClientRequest();

            });
     Task.Run(async () =>
        {
            TcpClient cl = await listener.AcceptTcpClientAsync();
            OnConnectionAccepted(cl);
        });
}

HandleClientRequest某些异步网络调用在哪里,例如从客户端读取请求并将其重复发送到服务器,就像您希望代理一样. listener.AcceptTcpClientAsync只是等待来自浏览器的下一个连接.

所以看起来Task.Run的重点只是允许AcceptTcpClientAsync在HandleClientRequest忙碌时被调用.

这似乎违背了我一直在阅读的建议,例如.http://blog.stephencleary.com/2013/10/taskrun-etiquette-and-proper-usage.html因为Task.Run正在包装网络,而不是CPU调用.

那么它应该如何工作呢,如果这是错的,它应该使用ThreadPool.QueueUserWorkerItem吗？

顺便说一句,上下文通常是一个控制台应用程序.