相关疑难解决方法(0)

我应该什么时候不使用.NET中的线程池？

看起来最好的选择是使用ThreadPool,在这种情况下,为什么它不是唯一的选择？

你有什么经历？

我有一个.NET 3.5 Windows服务.我正在使用一个小应用程序进行测试,该应用程序在启动后只是睡眠线程,随机时间间隔为300到6500毫秒.我对这个问题有各种各样的疑问.

1. 难道BackgroundWorker真的打算使用刚刚在的WinForms应用程序或者这只是无稽之谈,究竟是它调整到这种效果呢？
2. 我已经ThreadPool在这个问题和这个问题中读到了s .我不确定线程​​会持续半秒到几秒之间的问题对我来说有多大问题.这个理由足以让人看到其他地方吗？
3. 我自己最好只创建后台线程吗？

现实生活中的服务将轮询数据库中的待处理请求列表,为每个请求执行线程(限于一定数量的并发线程),每个线程将检查数据库中是否存在某些数据,如果它可以,或从流API下载,存储它,并返回该数据.下载将是消耗最多时间的部分.

我真的希望.NET 3.5 Framework能够回答这个问题,但如果在.NET 4.0下有更好或更有效的方法来实现这一点,我也想了解它们.更多信息的链接也非常受欢迎.

如果我有

public void Method(int m)
{
  ...
}

如何为此方法创建线程？

线程t =新线程((方法));

t.Start(米);

不管用.

我在前几天读到,对于长期运行的任务,我最好的办法是手动创建线程,而不是使用.NET的线程池或任务并行.当我正在学习c#线程时,我真的希望有人能够启发我,特别是对于长时间运行的IO任务.先感谢您.

据我所知,我有一些误导性的信息.我需要在后台运行一个单独的线程.

目前我这样做:

var task = Task.Factory.StartNew
         (CheckFiles
          , cancelCheckFile.Token
          , TaskCreationOptions.LongRunning
          , TaskScheduler.Default);//Check for files on another thread

 private void CheckFiles()
 {
    while (!cancelCheckFile.Token.IsCancellationRequested)
    {
        //do stuff
    }
 }

这总是为我创建一个新线程.但经过多次讨论后,即使将其标记为LongRunning也无法保证将创建新的线程.

在过去我做过这样的事情:

thQueueChecker = new Thread(new ThreadStart(CheckQueue));
thQueueChecker.IsBackground = true;
thQueueChecker.Name = "CheckQueues" + DateTime.Now.Ticks.ToString();
thQueueChecker.Start();


private void CheckQueue()
{
   while (!ProgramEnding)
   {
            //do stuff
   }
}

你会建议我回到这种方法来保证使用新线程吗？

我有一个void DoWork(object input)大约需要5秒才能完成的方法.我读过这个Thread比ThreadPool这些更长的操作更合适,但我遇到了一个问题.

我点击一个按钮,调用threadRun.Start(input)哪个运行并完成正常.我再次单击该按钮并收到以下异常:

Thread is running or terminated; it cannot restart.

你能否"重用"一个线程？我应该使用ThreadPool吗？与ThreadPool相比,为什么Thread"更适合更长时间的操作"？如果你不能重复使用一个线程,为什么要使用它(即它提供了哪些优势)？

我正在使用.NET 3.5,并试图解决一个问题(不是我的最高线程专家熊).

我有一个Windows服务,它有一个非常密集的进程,一直在运行,我把这个进程放在一个单独的线程上,以便我的服务的主线程可以处理操作任务 - 即服务审计周期,处理配置更改等,等等

我通过典型的ThreadStart启动线程到一个关闭进程的方法 - 称之为workerthread.

在这个workerthread我发送数据到另一台服务器,正如预期的那样,服务器不时重新启动并且连接丢失,我需要重新建立连接(我通过事件丢失连接通知我).从这里我做了我的重新连接逻辑,我重新开始运行,但是我很容易开始注意到的事情是我每次都在反复创建这个工作线程(不是我想要的).

现在,当我失去连接并启动一个新连接时,我可以杀死它,但这似乎是浪费资源.

我真正想做的是,将调用(即我的线程启动方法)编组回到仍在内存中的线程,尽管没有做任何事情.

请发布您有用的任何示例或文档.

谢谢.

我试图理解为什么Parallel.For在以下场景中能够胜过许多线程:考虑一批可以并行处理的作业.在处理这些作业时,可能会添加新工作,然后也需要对其进行处理.该Parallel.For解决方案将如下所示:

var jobs = new List<Job> { firstJob };
int startIdx = 0, endIdx = jobs.Count;
while (startIdx < endIdx) {
  Parallel.For(startIdx, endIdx, i => WorkJob(jobs[i]));
  startIdx = endIdx; endIdx = jobs.Count;
}

这意味着Parallel.For需要同步多次.考虑面包优先图算法算法; 同步的数量会非常大.浪费时间,不是吗？

尝试使用老式的线程方法:

var queue = new ConcurrentQueue<Job> { firstJob };
var threads = new List<Thread>();
var waitHandle = new AutoResetEvent(false);
int numBusy = 0;
for (int i = 0; i < maxThreads; i++) 
  threads.Add(new Thread(new ThreadStart(delegate {
    while (!queue.IsEmpty || numBusy > 0) { …

我想知道为什么在控制台应用程序中,如果我旋转一个新线程从Main运行,即使Main将到达终点它将等待,但是如果我启动一个新任务,它将退出而不是等待任务结束.

例如

static void Main(string[] args) 
{
    Thread t = new Thread(new ThreadStart(SomeMethod));
    t.Start();            
    // Main will wait, and app won't close until SomeMethod finishes
}

与

static void Main(string[] args)
{
    Task.Run(() => SomeMethod());
    // Main will close / app shuts down without waiting for SomeMethod to finish
}

我正在寻找实现一个生产者多个消费者多线程应用程序的最佳方案.目前我正在使用一个队列来共享缓冲区,但它比一个生产者一个消费者的情况要慢得多.我打算这样做:

Queue<item>[] buffs = new Queue<item>[N];
object[] _locks = new object[N];
static void Produce()
{
    int curIndex = 0;
    while(true)
    {
        // Produce item;
        lock(_locks[curIndex])
        {
            buffs[curIndex].Enqueue(curItem);
            Monitor.Pulse(_locks[curIndex]);
        }
        curIndex = (curIndex+1)%N;
    }
}

static void Consume(int myIndex)
{
    item curItem;
    while(true)
    {
        lock(_locks[myIndex])
        {
            while(buffs[myIndex].Count == 0)
                Monitor.Wait(_locks[myIndex]);
            curItem = buffs[myIndex].Dequeue();
        }
        // Consume item;
    }
}

static void main()
{
    int N = 100;
    Thread[] consumers = new Thread[N];
    for(int i = 0; i < N; i++)
    { …