标签: threadpool

我在Win32 nt5环境中编程.

我有一个将被多次调用的函数.每次调用都是原子的.我想用来利用QueueUserWorkItem多核处理器.

我遇到的问题是我只想让功能完成3秒钟.如果它在3秒内没有完成,我想终止该线程.

目前我正在做这样的事情:

HANDLE newThreadFuncCall= CreateThread(NULL,0,funcCall,&func_params,0,NULL);
DWORD result = WaitForSingleObject(newThreadFuncCall, 3000);
if(result == WAIT_TIMEOUT)
{
    TerminateThread(newThreadFuncCall,WAIT_TIMEOUT);
}

我只生成一个线程并等待3秒或完成.反正有没有做类似但QueueUserWorkItem用于排队工作的东西？

我在Silverlight代码隐藏中有一段代码看起来像这样:

foreach (MapLocation loc in e.Result)
        {

            testDict[loc.ElemId] = loc.ToString();

            this.Dispatcher.BeginInvoke(delegate()
            {
                Image icon = new Image();
                icon.SetValue(Image.SourceProperty, nurseIconSource);
                Canvas.SetLeft(icon, (double)loc.X * MAP_SCALE);
                Canvas.SetTop(icon, MAP_HEIGHT - (double)loc.Y * MAP_SCALE);
                icons[loc.ElemId] = icon;
                MainCanvas.Children.Add(icon);
            });
        }
    }

此循环在与UI线程分开的线程上运行25次.执行该方法后,testDict对象以所有25个条目结束,而图标字典仅存储第25个(最后一个)项目的条目.

这是我第一次使用Dispatcher.它不是故意被称为快速射击吗？我能想到的是,第一次调用委托是在最后一次循环之后,因此loc对象始终是同一个项目.这准确吗？

我是F#的新手,我已经从我在网上找到的各种例子中明确了下面的代码,试图更好地理解我如何使用它.目前,下面的代码从文件中读取机器列表并ping每台机器.我不得不将初始数组从文件分成25个机器的较小数组,以控制并发操作的数量,否则需要很长时间才能映射出机器列表.我希望能够使用线程池来管理线程,但我还没有找到让它工作的方法.任何指导都会很棒.我无法做到这一点:

let creatework  = FileLines|> Seq.map (fun elem -> ThreadPool.QueueUserWorkItem(new WaitCallback(dowork), elem))

这是完整的代码:

open System.Threading
open System
open System.IO

let filePath = "c:\qa\machines.txt"

let FileLines = File.ReadAllLines(filePath)

let count = FileLines.Length/25

type ProcessResult = { exitCode : int; stdout : string; stderr : string } 

let executeProcess (exe,cmdline) = 
    let psi = new System.Diagnostics.ProcessStartInfo(exe,cmdline) 
    psi.UseShellExecute <- false
    psi.RedirectStandardOutput <- true 
    psi.RedirectStandardError <- true 
    psi.CreateNoWindow <- true
    let p = System.Diagnostics.Process.Start(psi, EnableRaisingEvents = true) 
    let output = new System.Text.StringBuilder()
    let error …

我有一个要求,我想创建一个5线程的池,现在我想从这5个线程中的1个线程作为一个daemon线程,当这个特定的1个线程变为守护线程时,那么我想分配一些任务到那个与任何服务相关的守护程序线程,当java程序退出时我可以在窗口任务管理器中检查特定的守护程序线程是否还在执行该任务.请告知如何实现该目的..!因为我被困在这......

下面是我的代码......

public class StoppingThread extends Thread //extend thread class 
{
    // public  synchronized void run()
     //synchronized (this)

    private volatile boolean Completed = false;


    public void setCompleted() {
        Completed = true;
    }


    public void run()
    {
      for(int i=0;i<20 && !Completed;++i) {
          System.out.println(Thread.currentThread().getName());
        try {
          Thread.sleep(500);

          System.out.print(i +"\n"+ "..");
        } catch(Exception e) {
          e.printStackTrace();
        }
      } 
    } 

 public static void main(String... a) 
 {
     StoppingThread x = new StoppingThread();
     StoppingThread y = new StoppingThread();
     x.start();
     x.setName("first");
     x.setCompleted(); // Will complete …

所有

我正在研究一个小代码,用于在计算机进程中通过线程id搜索线程.

我的所有代码如下所示,请帮助查看.:)

    using System.Diagnostics;

    public class NKDiagnostics
    {
        private Process[] m_arrSysProcesses;

        private void Init()
        {
            m_arrSysProcesses = Process.GetProcesses(".");
        }
        public static ProcessThread[] GetProcessThreads(int nProcID)
        {
            try
            {
                Process proc = Process.GetProcessById(nProcID);
                ProcessThread[] threads = new ProcessThread[proc.Threads.Count];
                proc.Threads.CopyTo(threads, 0);
                return threads;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
    }

在另一个类中,我指定一个线程来执行我的名为的函数 DoNothing

    ThreadPool.QueueUserWorkItem((t) => Utility.DoNothing((TimeSpan)t), 
TimeSpan.FromMinutes(1));

而功能DoNothing代码是

public class Utility
    {
        public static void DoNothing(TimeSpan timeout, TextBox txtThreadId)
        {
            TimeoutHelper helper = new TimeoutHelper(timeout);
            while (true) …

所以我在MVC控制器方法里面有以下代码:

public ActionResult ProcessFile () 
{
    ThreadStart threadStart = new ThreadStart ( ()=>{

        // Doing some long processing that takes 20 minute 
    } );

    Thread thread = new Thread(threadStart); 
    thread.Start();
}

这里的问题是当多个请求发送到此控制器方法时,线程被杀死.我需要Thread继续工作,直到处理结束,似乎资源占用了大量资源,线程可以继续工作.如果我从Windows应用程序或服务运行该过程它完美地工作,它只是从Web应用程序启动时遇到问题.

如果我有这个代码:

genetic = new Genetic();
genetic.foundNewBestGroupTour += new Genetico.NewBestGroupTourEventHandler(genetico_foundNewBestGroupTour);

怎么+=办？

genetic.foundNewBestGroupTour -= new Genetico.NewBestGroupTourEventHandler(genetico_foundNewBestGroupTour);

怎么-=办？

我正在研究一个需要执行一些光学字符识别的多线程应用程序.该应用程序的要求是它必须真正,非常快速地工作.

有一段时间,我必须同时阅读6个不同的单词.所以我正在做的是,开始6个线程,一个专门用于阅读每个单词的线程.

但是,我想知道我是否应该更进一步,并为一个单词中的每个字符开始一个线程.例如,如果我有6个单词且每个单词有大约5-6个字符,这将意味着30-36个线程(对于更长的单词,可能高达50-70个线程).

要处理每个单独的字符,它似乎需要10-30毫秒,每个字总共需要200-300毫秒.(我需要将它降低到每个单词100毫秒或更少).

哪种策略实际上会给我带来更好的表现？每个字一个线程,或每个字符一个线程？

我很多时候在线程的帮助下调用方法

static void Main( string[] args )
{
    Thread t = new Thread( MyFunction );
    t.Start();
}

static void MyFunction()
{
    //code goes here
}

有些时候我ThreadPool也喜欢上课

System.Threading.ThreadPool.QueueUserWorkItem(delegate {
    MyFunction();
}, null);

但我不明白在线程类或ThreadPool类的帮助下调用任何方法有什么区别

所以我正在寻找一个关于Thread和ThreadPoolclass 之间有什么区别的好讨论.还需要知道何时应该使用Thread类来调用方法以及何时ThreadPool调用任何方法的类？如果可能的话,还要与样本代码一起讨论样本情况

另一个非常重要的问题是,如果我启动多个线程,那么我的应用程序性能会变低还是差？如果是,那么告诉我为什么......？

现在还告诉我什么是BackgroundWorker类以及它与Thread和ThreadPool类的不同之处.我听到BackgroundWorker该类还创建了一个单独的线程来运行任何方法.所以请讨论它与Thread和ThreadPoolclass的不同之处以及何时应该去BackgroundWorker上课.

这是一个小样本代码 BackgroundWorker

private void button1_Click(object sender, EventArgs e)
    {
        BackgroundWorker bw = new BackgroundWorker();

        // this allows our worker to report progress during work
        bw.WorkerReportsProgress = …

自定义线程池的建议大小为number_of_cores + 1(请参见此处和此处).因此,假设在具有2个内核的系统上有一个Spring应用程序,配置就像这样

<task:executor id="taskExecutor" 
pool-size="#{T(java.lang.Runtime).getRuntime().availableProcessors() + 1}" />
<task:annotation-driven executor="taskExecutor" />

在这种情况下,将在多个请求之间共享一个ExecutorService.因此,如果10个请求到达服务器,则只能在ExecutorService中同时执行其中3个请求.这可能会产生瓶颈,并且结果会随着请求数量的增加而变得更糟(请记住:默认情况下,tomcat最多可以处理200个并发请求= 200个线程).该应用程序将执行得更好,没有任何池.

通常,一个核心可以同时处理多个线程.例如,我创建了一个服务,它调用两次https://httpbin.org/delay/2.每次调用都需要2秒才能执行.因此,如果没有使用线程池,则服务平均响应4.5秒(使用20个同时请求进行测试).如果使用线程池,则响应因池大小和硬件而异.我在具有不同池大小的4核心机器上运行测试.以下是最小,最大和平均响应时间(以毫秒为单位)的测试结果

从结果可以得出结论,最佳平均时间是最大池大小.池中5(4个核心+ 1)线程的平均时间比没有池的结果更糟糕.因此,在我看来,如果请求不占用大量CPU时间,那么将线程池限制为Web应用程序中的核心数+ 1是没有意义的.

对于非CPU要求的Web服务,是否有人发现在2或4核心机器上将池大小设置为20(甚至更多)有什么问题？