标签: threadpool

是否有一种很好的方法来实现一个执行策略，该策略可以根据某种识别方案确定哪个线程将处理给定的任务？或者这甚至是一个好方法？

我需要处理 1-many 文件，我将在交错块中接收这些文件。当块到达时，我想完成处理该块的任务。问题是我没有让处理代码成为线程安全的奢侈，所以一旦池中的线程处理了文件中的一个块，我需要同一个线程来处理该文件的其余部分。我不在乎一个线程是否正在同时处理多个文件，但我不能同时处理同一个文件的池中的多个线程。

《Java 并发实践》一书指出，您可以使用执行策略来确定“任务将在哪个线程中执行？”，但我不明白如何执行。

谢谢

我使用Multi-thread在java中同时扫描不同的URL.如果请求时间总和超过100,000,则存在错误.我已经关闭,我应该关闭.这是我的servlet的代码

private String proyGetHttp(String url) throws ParseException, IOException,
            InterruptedException {

        String content = "";
        getMethod = new HttpGet(url);
        HttpResponse response = null;
        HttpEntity httpEntity = null;
        boolean success = false;
        while (!success) {
            System.out.println("url?" + url + "?connect...");
            try {
                response = client.execute(getMethod);
                httpEntity = response.getEntity();
                StringBuffer sb = new StringBuffer();
                if (httpEntity != null) {
                    BufferedReader in = null;
                    InputStream instream = httpEntity.getContent();
                    try {
                        in = new BufferedReader(new InputStreamReader(instream));
                        String lineContent = "";
                        while(lineContent != null){
                            sb.append(lineContent);
                            lineContent …

现在我正在产生3个线程来做一些并发工作,我使用Threadpooling进行设置,因为我希望所有线程同时运行,但是在继续之前让所有线程完成.以下是代码的要点:

_resetEvents = new ManualResetEvent[3];

_resetEvents[0] = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(DoWorkA);
_resetEvents[1] = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(DoWorkB);
_resetEvents[2] = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(DoWorkC);

WaitHandle.WaitAll(_resetEvents);

但是我的方法都使用相同的代码库,我把它分解为3种方法只是为了设置()正确的线程.

private void DoWorkA(object o) {
    var workerClass = new WorkerClass();
        workerClass.Process();
    _resetEvents[0].Set();
}
private void DoWorkB(object o) {
    var workerClass = new WorkerClass();
        workerClass.Process();
    _resetEvents[1].Set();
}
private void DoWorkC(object o) {
    var workerClass = new WorkerClass();
        workerClass.Process();
    _resetEvents[2].Set();
}

显然它不是很干,因为我想拥有4个或5个线程,但是想要确保Set()在完成后设置正确的_resetEvent.

有关如何安全地做到这一点并使其更干燥和可扩展的任何建议？

我知道这段代码之间有区别：

var streamWriter = new StreamWriter("something.txt");
streamWriter.WriteAsync("text");

和这个：

var streamWriter = new StreamWriter("something.txt");
Task.Run(()=> streamWriter.Write("text"));

第一个更有意义。

在不同的情况下，当我等待结果时，此代码：

var streamReader = new StreamReader("something.txt")
char[] chars = new char[10];

Task<int> task = streamReader.ReadAsync(chars, 0, chars.Length);
//Do something...

int num = await task;
//Do something with num...

比这更有意义：

var streamReader = new StreamReader("something.txt")
char[] chars = new char[10];

Task<int> task = Task.Run(()=>streamReader.Read(chars, 0, chars.Length));
//Do something...

int num = await task;
//Do something with num...

我想使用内置的异步 API 不仅在清晰度上更好，而且它实际上ThreadPool比让ThreadPool线程无故等待更好、更有效地管理线程。

这样对吗？

当我调用我的多线程perl脚本时,在几个场景中,它会引发一些类似于以下的异常.对不起,我无法分享代码.但如果真的需要我可以尝试构建一个片段(如果确实需要).因为我猜这应该有一些理论上的答案.

*** glibc detected *** perl: double free or corruption (!prev): 0x00007f775401e9a0 ***
======= Backtrace: =========
/lib64/libc.so.6[0x3d74c75e66]
/lib64/libc.so.6[0x3d74c789b3]
/lib64/libc.so.6[0x3d74c7b880]
/lib64/libc.so.6(realloc+0xe5)[0x3d74c7baf5]
/usr/lib/../lib64/libcrypto.so.10(CRYPTO_realloc+0x5f)[0x7f775907bd8f]
/usr/lib/../lib64/libcrypto.so.10(lh_insert+0xee)[0x7f77590f763e]
/usr/lib/../lib64/libcrypto.so.10(OBJ_NAME_add+0x6b)[0x7f775907f12b]
/usr/lib/../lib64/libcrypto.so.10(EVP_add_cipher+0x27)[0x7f7759102387]
/usr/lib/../lib64/libcrypto.so.10(OpenSSL_add_all_ciphers+0x4b7)[0x7f7759106a07]
/usr/lib/../lib64/libcrypto.so.10(OPENSSL_add_all_algorithms_noconf+0xe)[0x7f775910653e]
/usr/local/lib/libssh2.so.1(libssh2_init+0x39)[0x7f77596800b9]

为什么我会收到这样的错误？

我正在使用Thread :: Queue; 使用threads :: shared; 请让我知道你的看法.

下面是线程库版本信息.

use threads; - installed v2.15 (latest - 2.16)
use Thread::Queue; - installed v3.12 (up to date)
use threads::shared; - installed v1.56 (latest - 1.57)
perl - installed v5.26.1

其他图书馆::

use YAML::XS 'LoadFile';  - 0.66 up to date
use Net::Netconf::Manager; - 1.02 up to date …

我有两个问题.. 1. 线程和线程池有什么区别？我的系统中可以有多个线程池（不是线程）吗？2.我一直在读，线程池中线程的一般大小与处理器数相同或比处理器多一个。我使用的是四核处理器，这意味着我可以在线程池中有 4 或 5 个线程。但是在任务管理器下，我的系统随时显示超过 1000 个线程处于活动状态..??

我试图了解使用 common Threads 和Tasks之间的好处。第一个进入System.Threading命名空间，后者进入System.Threading.Tasks命名空间。所以，只是为了玩和熟悉它们，我写了这个程序C#：

class Program
{
    static void Main(string[] args)
    {
        long ticksAtStart = DateTime.UtcNow.Ticks;

        new Thread(() => { ExecuteAsyn("Thread", DateTime.UtcNow.Ticks); }).Start();
        Console.WriteLine("Using Thread: " + (DateTime.UtcNow.Ticks - ticksAtStart));

        ticksAtStart = DateTime.UtcNow.Ticks;

        Task g = Task.Factory.StartNew(() => ExecuteAsyn("TPL", DateTime.UtcNow.Ticks));
        Console.WriteLine("Using TPL: " + (DateTime.UtcNow.Ticks - ticksAtStart));

        g.Wait();
        Console.ReadKey();
    }

    private static void ExecuteAsyn(string source, long ticksAtExecutionTime)
    {
        Console.WriteLine("Hello World! Using " + source + " the difference between initialization and …

我的 Windows 服务卡在启动状态。下面是里面的代码onstart()。log()将一些值记录到文件中。

while (true)
        {
            log();
            Thread.Sleep(TimeSpan.FromMinutes(5));
        }

一些实验后，我改变了onstart()对

while (true)
        {
            log();
            await Task.Delay(TimeSpan.FromMinutes(5)).ConfigureAwait(false);
        }

一旦我更改了代码服务状态更改为正在运行并且工作正常。我认为 Thread.Sleep() 和 Task.Delay() 之间有什么区别，我认为两者都在延迟执行。谁能帮我理解

我试图让线程池的基础知识非常强大。我了解到它在内部使用阻塞队列来“窃取”任务并将它们运行到池中的给定线程中。这意味着如果我有 10 个任务和 5 个线程，它只能同时运行 5 个任务，直到 1 个任务完全完成。

问题是：为什么不并发？为什么不只是对这 10 个任务进行时间切片？这个实现的原因是什么？

考虑以下代码：

class Test {
    public static void main(String... args) {
        var t = new Test();
        while(true) {
            t.work();
        }
    }
    public void work() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        try {
             /* Do work */
        }
        finally {
            executorService.shutdown();
        }
    }
}

在应用程序的生命周期中可以有多少个线程池（不是同时）是否有限制。

我尝试查看源代码并运行此测试一段时间，但似乎没有限制。一旦线程池计数器溢出会发生什么？