相关疑难解决方法(0)

我知道现在大多数处理器都有两个或更多内核,多核编程风靡一时.是否有在Java中使用它的功能？我知道Java有一个Thread类,但我也知道这在很长一段时间之后才开始流行.如果我可以在Java中使用多个内核,我会使用哪种类/技术？

Java 5引入了Executor框架形式的线程池对异步任务执行的支持,其核心是java.util.concurrent.ThreadPoolExecutor实现的线程池.Java 7以java.util.concurrent.ForkJoinPool的形式添加了一个备用线程池.

查看各自的API,ForkJoinPool在标准场景中提供了ThreadPoolExecutor功能的超集(虽然严格来说ThreadPoolExecutor提供了比ForkJoinPool更多的调优机会).除此之外,fork/join任务看起来更快(可能是因为工作窃取调度程序)的观察结果显然需要更少的线程(由于非阻塞连接操作),可能会让人觉得ThreadPoolExecutor已被取代ForkJoinPool.

但这真的是对的吗？我读过的所有材料似乎总结为两种类型的线程池之间相当模糊的区别:

• ForkJoinPool适用于许多依赖的,任务生成的,简短的,几乎不会阻塞(即计算密集型)的任务
• ThreadPoolExecutor用于少量,独立,外部生成,长期,有时阻塞的任务

这种区别是否正确？我们能说出更具体的内容吗？

好标题说,它Executors.newSingleThreadExecutor().execute(command)和之间有什么区别new Thread(command).start();

我有一个关于如何ExecutorService在Java中工作的基本问题.

很难看出简单地创建Threads并行执行某些任务和将每个任务分配给它们之间的区别ThreadPool.

使用起来ExecutorService也非常简单和有效,所以我想知道为什么我们不一直使用它.

这只是一种比另一种方式更快地执行其工作的问题吗？

这里有两个非常简单的例子来说明两种方式之间的区别:

使用执行程序服务:Hello World(任务)

static class HelloTask implements Runnable {
    String msg;

    public HelloTask(String msg) {
        this.msg = msg; 
    }
    public void run() {
        long id = Thread.currentThread().getId();
        System.out.println(msg + " from thread:" + id);
    }
}

使用执行程序服务:Hello World(创建执行程序,提交)

static class HelloTask {
    public static void main(String[] args) {
        int ntasks = 1000;
        ExecutorService exs = Executors.newFixedThreadPool(4);

        for (int i=0; i<ntasks; i++) { 
            HelloTask t = new HelloTask("Hello from …

我有一个多线程java项目,我想添加一个方法stop()来停止所有正在运行的线程.问题是这个项目是由其他人开发的,我不熟悉它如何实现多个线程.

我所知道的是,一旦项目开始,就会调用许多线程并且它们会永远运行.有没有办法找到所有正在运行的线程并阻止它们？我搜索了很多,并找到了如何获取正在运行的线程列表:

Set<Thread> threadSet = Thread.getAllStackTraces().keySet();

下一步要做什么来阻止所有正在运行的线程？

我想要停止这些线程的原因是我需要将此项目作为一个包部署到OSGi容器.捆绑包启动后,多个线程将永远运行.所以我需要实现一个destroy()方法来阻止所有线程来控制bundle的生命周期.

怎么样

for (Thread t : Thread.getAllStackTraces().keySet()) 
{  if (t.getState()==Thread.State.RUNNABLE) 
     t.interrupt(); 
} 

for (Thread t : Thread.getAllStackTraces().keySet()) 
{  if (t.getState()==Thread.State.RUNNABLE) 
     t.stop(); 
}

我的问题是:使用它是否有意义Executors.newFixedThreadPool(1)??.在两个线程(main + oneAnotherThread)场景中,使用执行程序服务是否有效？是否通过调用new Runnable(){ }比使用ExecutorService更好地直接创建新线程？在这种情况下使用ExecutorService有什么好处和缺点？

PS:主线程和oneAnotherThread不访问任何公共资源.

我经历过:使用ExecutorService有什么好处？.并且一次只有一个线程!

我想从事多线程,但我目前的项目没有这样的机会.有人请指导我应该从哪里开始.我需要实时场景,以便我可以直接跳转到编码.我也是并排阅读.

你可以参考一些网站进行练习吗？

在我的应用程序中,我有4个不同的进程,这些进程在一些小的暂停时永久运行.

当前版本的代码在单独的旧学校线程中执行每个进程:

Thread nlpAnalyzer = new Thread(() -> {

    // infine lop for auto restore in case of crash
    //noinspection InfiniteLoopStatement
    while (true) {
        try {
            // this method should run permanently, pauses implemented internally
            NLPAnalyzer.analyzeNLP(dbCollection);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});

nlpAnalyzer.setName("im_nlpAnalyzer");
nlpAnalyzer.start();

现在我想用这个代码重构这个代码ExecutorService.为了做到这一点,我可以使用至少两种方法:

• newFixedThreadPool(numOfProc);
• numOfProc * newSingleThreadExecutor().

我的问题:

1. 有什么理由我更喜欢一种选择吗？
2. 使用X线程生成线程池还是生成X newSingleThreadExecutors 更接受什么？
3. Pro et contra的每种方法？

我想检查多线程是否比单线程快，然后我在这里做一个演示：

public class ThreadSpeedTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("cpu number:"
                + Runtime.getRuntime().availableProcessors());
        singleThreadStart();
//      secondThreadStart();
//      fiveThreadStart();
    }

    private static void sum() {
        long sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;
        }
        System.out.println(sum);
    }

    private static void singleThreadStart() {
        new Thread(new Runnable() {

            public void run() {
                long start = System.nanoTime();
    //          sum();
    //          sum();
    //          sum();
                sum();
                sum();
                long end = System.nanoTime(); …

参考Java 的 Fork/Join vs ExecutorService - 何时使用哪个？，一个传统的线程池通常用于处理很多独立的请求；和 aForkJoinPool用于处理连贯/递归任务，其中一个任务可能会产生另一个子任务并稍后加入。

那么，为什么默认parallelStream使用Java-8ForkJoinPool而不是传统的执行器呢？

在很多情况下，我们forEach()在stream()orparallelStream()之后使用，然后提交一个功能接口作为参数。在我看来，这些任务是独立的，不是吗？

我们在java中有三种不同的多线程技术 - Fork/Join池,Executor Service和CountDownLatch

Fork/Join pool(http://www.javacodegeeks.com/2011/02/java-forkjoin-parallel-programming.html)

Fork/Join框架旨在使分而治之的算法易于并行化.这种类型的算法非常适合于可以分为两个或更多相同类型的子问题的问题.他们使用递归将问题分解为简单的任务,直到这些变得足够简单直接解决.然后组合子问题的解决方案以给出原始问题的解决方案

ExecutorService是一个扩展Executor类并表示异步执行的接口.它为我们提供了管理结束和检测异步任务进度的机制.

invokeAll():执行给定的任务,返回一个Futures列表,其中包含完成后的状态和结果.对于返回列表的每个元素,Future.isDone()都为true.

CountDownLatch :( http://examples.javacodegeeks.com/core-java/util/concurrent/countdownlatch-concurrent/java-util-concurrent-countdownlatch-example/)

CountDownLatch用于同步,以允许一个或多个线程等待,直到在其他线程中执行的一组操作完成.

我的假设:

在这两种替代方案中,只有在完成所有任务/线程后才能知道最终结果.

这三种选择是互补的还是互补的？