标签: threadpool

我目前正在互联网上搜索自定义线程池实现.我找到了一个使用IOCP的实现.我想知道使用它们有什么好处？他们提供工作偷窃,或类似的东西,我真的能找到答案......

我不太清楚怎么说这个,所以我只是粘贴我的代码并提出问题:

private void remoteAction_JobStatusUpdated(JobStatus status) {
    lock (status) {
        status.LastUpdatedTime = DateTime.Now;
        doForEachClient(c => c.OnJobStatusUpdated(status));
        OnJobStatusUpdated(status);
    }
}

private void doForEachClient(Action<IRemoteClient> task) {
    lock (clients) {
        foreach (KeyValuePair<RemoteClientId, IRemoteClient> entry in clients) {
            IRemoteClient clientProxy = entry.Value;
            RemoteClientId clientId = entry.Key;
            ThreadPool.QueueUserWorkItem(delegate {
                try {
                    task(clientProxy);
#pragma warning disable 168
                } catch (CommunicationException ex) {
#pragma warning restore 168
                    RemoveClient(clientId);
                }
            });
        }
    }
}

假设修改status对象的任何其他代码将首先获得对它的锁定.

由于status对象一直传递到多个ThreadPool线程,并且调用ThreadPool.QueueUserWorkItem将在实际任务完成之前完成,我是否确保将相同的status对象发送到所有客户端？

换句话说,lock (status) …

当前实现:等待直到parallelCount收集值,用于ThreadPool处理值,等待所有线程完成,重新收集另一组值等等...

码:

private static int parallelCount = 5;
private int taskIndex;
private object[] paramObjects;

// Each ThreadPool thread should access only one item of the array, 
// release object when done, to be used by another thread
private object[] reusableObjects = new object[parallelCount];     

private void MultiThreadedGenerate(object paramObject)
{
    paramObjects[taskIndex] = paramObject;
    taskIndex++;

    if (taskIndex == parallelCount)
    { 
        MultiThreadedGenerate();

        // Reset
        taskIndex = 0;
    }
}

/*
 * Called when 'paramObjects' array gets filled
 */
private void …

我有一个命令行应用程序.它运行循环说100次,并在循环中使用线程调度任务.我正在使用ExecutorService,因此任何时候都有4个线程在运行.

循环结束后,我想打印摘要消息.例如,完成所有100个任务所花费的时间.当我逐步完成代码时,调试器直接进入摘要部分,但其他任务仍在运行.我理解这是因为每个线程都是自己运行的.那么如何在所有线程完成后才打印消息？

ExecutorService exec = Executors.newFixedThreadPool(4);

long startTime = System.currentTimeMillis();

for (int i = 0; i < 100; i++) {

    Runnable requestHandler = new Runnable() {
        @Override
        public void run() {
            try {
                // call task function in here
            } catch (Exception ex) {
            }
        }
    };
    exec.execute(requestHandler);
}

exec.shutdown();

long endTime = System.currentTimeMillis();

LOGGER.info("******************SUMMARY******************");
LOGGER.info("Time taken : " + ((endTime - startTime)/1000) + " seconds, " 
                            + ((endTime - startTime)/1000/60) + " minutes");

我有两个问题:

1. 有没有办法插入一个ThreadPool没有得到对象作为参数的functoin(要向threadPool插入一个函数,它需要是返回void和ged一个参数-object的函数),例如我想插入这个函数:double foo(int a,double b,string c)？
2. 有没有办法wait在池中进行线程(如连接)？

所以我不知道如何提出这个问题,可能是我在任何地方找到问题的原因之一.

所以我的设置是我有一堂课

public class Connection
{
    public static event EventHandler LogggedIn;
    public static TDConnection TDC {get;set;}
    public string Authenticate(){...}
    public static void Login()
    {
        if (Connection.TDC.Connected)
        {
            _bw = new BackgroundWorker
            {
                WorkerReportsProgress = true,
                WorkerSupportsCancellation = true
            };
            _bw.DoWork += ConnectToProject_DoWork;
            _bw.RunWorkerCompleted += ConnectToProject_RunWorkerCompleted;

            _bw.RunWorkerAsync(Connection.TDC);
        }
    }

    private static void ConnectToProject_DoWork(object o, DoWorkEventArgs e)
    {
        Connection.TDC.ConnectProjectEx(Connection.Domain, Connection.Project, Connection.UserName, Utilities.Encryption.AESEncryption.Decrypt(Connection.Password, "fsd*#(dfs(((>>>???fdjs"));
    }

    private static void ConnectToProject_RunWorkerCompleted(object o, RunWorkerCompletedEventArgs e)
    {
        LogggedIn(null, new EventArgs());
    }
}

在我的主类中,我实例化一个新的Connection并调用Login,它在TDConnection中打开一个与ALM的新连接.在我的线程中,我想在我的线程中使用这个已经打开的连接.根据我的阅读,如果我这样做,我的UI将阻止因为我在UI线程上使用成员的方法,即使我在后台工作者内部.

我发现这样做的一个解决方案:

private static void …

我想知道使用ListenableFuture+addCallback()代替的优势是什么invokeAll(),以防万一我只想获得所有任务的结果.

是否invokeAll()隐藏了抛出的任何异常？如果我正在使用invokeAll(),我需要处理其他任何事情,作为addCallback()提供onSuccess()和onFailure()方法,但没有这样的功能invokeAll().

提前致谢!

我正在寻找一个调用Thread.Sleep的替代方法,它不会阻塞线程,而是将线程返回到线程池中.这样的事情存在吗？

我的项目中有一个异步任务,如下所示.

@SuppressLint("NewApi")

private void callTask() {

    new Task() {

      @Override
      protected void doInBackground(String... params) {

      }
     }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,
                string1,string2 );
   }

我在for循环中调用这个callTask​​()方法10次​​.

我的任务平行执行,工作正常.我想在一个时间点停止所有任务.我怎样才能做到这一点？

这个问题应该比我的前几个简单一些.我在我的程序中实现了以下工作队列:

Pool.h:

// tpool class
// It's always closed. :glasses:
#ifndef __POOL_H
#define __POOL_H
class tpool {
    public:
        tpool( std::size_t tpool_size );
        ~tpool();
        template< typename Task >
        void run_task( Task task ){
        boost::unique_lock< boost::mutex > lock( mutex_ );
            if( 0 < available_ ) {
                --available_;
                io_service_.post( boost::bind( &tpool::wrap_task, this, boost::function< void() > ( task ) ) );
            }
        }
    private:
        boost::asio::io_service io_service_;
        boost::asio::io_service::work work_;
        boost::thread_group threads_;
        std::size_t available_;
        boost::mutex mutex_;
        void wrap_task( boost::function< void() > task );
};
extern tpool …