如何解决简单的线程池管理器
我想要一个线程池，我可以在其中设置线程的优先级，而且我希望它非常非常简单。下面是我写的代码。它使用存储在四个列表中的一组线程。如果没有可用线程，则代码转移到不同的线程库并调用补充方法将新线程添加到没有可用线程的库中。我遇到的问题是，尽管它可以执行传递的委托，但速度非常慢。关于原因的任何想法？
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace xThreadPool
{
public class Pool
{
protected List<Tuple<AccessObject,Thread>>[] threadsOne;
protected List<Tuple<AccessObject,Thread>> OffLoadThreads;
private int poolSize;
protected object threadLock = new object();
protected object offLoadLock = new object();
public Pool(int size)
{
threadsOne = new List<Tuple<AccessObject,Thread>>[4];
OffLoadThreads = new List<Tuple<AccessObject,Thread>>();
poolSize = size;
for(byte x = 0;x<4;x++)
ReplenishThreads(x);
}
/// <summary>
/// Method removes any stopped threads that were off loaded when they were running to preserve them.
/// </summary>
protected void RemoveDeadThreads()
{
lock (offLoadLock)
{
foreach (Tuple<AccessObject,Thread> aThread in OffLoadThreads.ToArray())
{
if (aThread.Item2.ThreadState == ThreadState.Stopped)
{
OffLoadThreads.Remove(aThread);
}
}
}
}
/// <summary>
/// This method offloads any running threads and creates a new list to add new threads to a thread bank
/// from the array list indexed by z.
/// </summary>
/// <param name="z"></param>
protected void ReplenishThreads(byte z)
{
lock (threadLock)
{
if(threadsOne[z] != null)
{
var runningThreads = threadsOne[z].Where(x => x.Item2.ThreadState == ThreadState.Running);
lock (offLoadLock)
OffLoadThreads.AddRange(runningThreads.ToArray());
}
threadsOne[z] = new List<Tuple<AccessObject,Thread>>();
for (int x = 0; x < poolSize; x++)
{
var access = new AccessObject(x);
ThreadStart aStart = new ThreadStart(access.ExecuteMethod);
var newEntry = new Tuple<AccessObject,Thread>(access,new Thread(aStart));
newEntry.Item2.Start();
threadsOne[z].Add(newEntry);
}
Task.Run(() => RemoveDeadThreads());
}
}
/// <summary>
/// This method pushes the delegate onto a thread from a list of available threads.
/// </summary>
/// <param name="method"></param>
/// <param name="setPriority"></param>
public void Run(Action method,ThreadPriority setPriority = ThreadPriority.AboveNormal)
{
Tuple<AccessObject,Thread> aThread = default;
byte z = 0;
do
{
lock (threadLock)
{
aThread = threadsOne[z].Where(x =>x.Item2.ThreadState == ThreadState.Suspended).FirstOrDefault();
if(aThread == null)
{
Task.Run(()=>ReplenishThreads(z));
if (z < 3)
z++;
else
z = 0;
}
}
} while (aThread == null);
aThread.Item1.MethodToStart = method;
aThread.Item2.Priority = setPriority;
aThread.Item2.Resume();
}
}
/// <summary>
/// This class is used to control a thread and exection of an applied delegate
/// </summary>
public class AccessObject
{
public int ID { set; get; }
public Action MethodToStart { set; get; }
public AccessObject(int identifier)
{
ID = identifier;
}
/// <summary>
/// This is the executing method for the applied delegate MethodToStart
/// </summary>
public void ExecuteMethod()
{
Thread.CurrentThread.Suspend();
MethodToStart();
}
}
}
解决方法
开始自己的线程是昂贵的。与其这样做，不如考虑使用 ThreadPool - 您仍然可以在将作业发送到 ThreadPool 之前添加优先级队列，但不会产生启动新线程的成本。
,我设法保留了线程而不必补充它们，以下是代码：
/// <summary>
/// This is the executing method for the applied delegate MethodToStart
/// </summary>
public void ExecuteMethod()
{
do
{
Thread.CurrentThread.Suspend();
MethodToStart();
} while (!StopThread);
}
}
以下是对类所做的全部更改：
public class Pool
{
protected List<AccessObject>[] threadsOne;
private int poolSize;
protected object threadLock = new object();
public Pool(int size)
{
threadsOne = new List<AccessObject>[4];
poolSize = size;
for(byte x = 0;x<4;x++)
BuildPooledThreads(x);
}
/// <summary>
/// This method creates a new list to add new threads to a thread bank
/// from the array list indexed by z.
/// </summary>
/// <param name="z"></param>
protected void BuildPooledThreads(byte z)
{
threadsOne[z] = new List<AccessObject>();
for (int x = 0; x < poolSize; x++)
{
var access = new AccessObject(x);
threadsOne[z].Add(access);
}
}
/// <summary>
/// This method pushes the delegate onto a thread from a list of available threads.
/// </summary>
/// <param name="method"></param>
/// <param name="setPriority"></param>
public void Run(Action method,ThreadPriority setPriority = ThreadPriority.AboveNormal)
{
AccessObject aThread = default;
byte z = 0;
lock (threadLock)
{
do
{
aThread = threadsOne[z].Where(x => x.StoredThread.ThreadState == ThreadState.Suspended).FirstOrDefault();
if (aThread == null)
{
if (z < 3)
z++;
else
z = 0;
}
} while (aThread == null);
aThread.MethodToStart = method;
aThread.StoredThread.Priority = setPriority;
aThread.StoredThread.Resume();
}
}
}
/// <summary>
/// This class is used to control a thread and exection of an applied delegate
/// </summary>
public class AccessObject
{
public int ID { set; get; }
public Action MethodToStart { set; get; }
public bool StopThread { set; get; }
public Thread StoredThread { private set; get; }
public AccessObject(int identifier)
{
ID = identifier;
StopThread = false;
ThreadStart aStart = new ThreadStart(ExecuteMethod);
StoredThread = new Thread(aStart);
StoredThread.Start();
}
/// <summary>
/// This is the executing method for the applied delegate MethodToStart
/// </summary>
public void ExecuteMethod()
{
do
{
Thread.CurrentThread.Suspend();
MethodToStart();
} while (!StopThread);
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。