文档章节

主线程等待几个子线程执行完成方案

javahongxi
 javahongxi
发布于 2017/08/25 23:21
字数 805
阅读 4
收藏 0

 有时,为了程序的性能,我们有必要对程序中的for循环(含有sql/rpc操作)进行并发处理,要求是并发处理完之后才能继续执行主线程。现给出如下两种方案:

 

1. CountDownLatch

package com.itlong.whatsmars.base.sync;

import java.util.concurrent.CountDownLatch;

/**
 * Created by shenhongxi on 2016/8/12.
 */
public class CountDownLatchTest {

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            new Thread(new SubRunnable(i, latch)).start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() - start);

        System.out.println("Main finished");
    }

    static class SubRunnable implements Runnable {
        private int id = -1;
        private CountDownLatch latch;

        SubRunnable(int id, CountDownLatch latch) {
            this.id = id;
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(3000);
                System.out.println(String
                        .format("Sub Thread %d finished", id));
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        }
    }
}

 CountDownLatch用队列来存放任务,主要是一个构造器和两个方法,相关代码这里不予赘述。CountDownLatch很贴合我们的要求,但没用到线程池,而且latch是只提供了计数功能然后子线程的逻辑有没有可能会在主线程逻辑之后执行??,综合考虑,我推荐下面的这种方案。

 

2. ExecutorService

package com.itlong.whatsmars.base.sync;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by shenhongxi on 2016/8/12.
 */
public class CallableTest {

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);

        List<Callable<Void>> subs = new ArrayList<Callable<Void>>();
        for (int i = 0; i < 3; i++) {
            subs.add(new SubCallable(i));
        }

        long start = System.currentTimeMillis();
        try {
            pool.invokeAll(subs);
        } finally {
            pool.shutdown();
        }
        System.out.println(System.currentTimeMillis() - start);

        System.out.println("Main finished");
    }

    static class SubCallable implements Callable<Void> {
        private int id = -1;

        public SubCallable(int id) {
            this.id = id;
        }

        @Override
        public Void call() throws Exception {
            try {
                Thread.sleep(3000);
                System.out.println(String
                        .format("Child Thread %d finished", id));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

}

 AbstractExecutorService

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
        if (tasks == null)
            throw new NullPointerException();
        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<T> t : tasks) {
                RunnableFuture<T> f = newTaskFor(t);
                futures.add(f);
                execute(f);
            }
            for (Future<T> f : futures) {
                if (!f.isDone()) {
                    try {
                        f.get();
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }

 

接下来我做了个join的试验,发现同样可以达到目的,但不推荐此法。

package com.itlong.whatsmars.base.sync;

/**
 * Created by shenhongxi on 2016/8/12.
 * 子线程与主线程是顺序执行的,各子线程之间还是异步的
 */
public class JoinTest {

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(new SubRunnable(0));
        Thread t2 = new Thread(new SubRunnable(1));
        Thread t3 = new Thread(new SubRunnable(2));

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
        System.out.println(System.currentTimeMillis() - start);

        System.out.println("Main finished");
    }

    static class SubRunnable implements Runnable {
        private int id = -1;

        SubRunnable(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            try {
                System.out.println("hi, I'm id-" + id);
                Thread.sleep(9000);
                System.out.println(String
                        .format("Sub Thread %d finished", id));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

 

最后,我们顺便提下org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor

public class ThreadPoolTaskExecutor extends ExecutorConfigurationSupport implements SchedulingTaskExecutor {

	private final Object poolSizeMonitor = new Object();

	private int corePoolSize = 1;

	private int maxPoolSize = Integer.MAX_VALUE;

	private int keepAliveSeconds = 60;

	private boolean allowCoreThreadTimeOut = false;

	private int queueCapacity = Integer.MAX_VALUE;

	private ThreadPoolExecutor threadPoolExecutor;


	/**
	 * Set the ThreadPoolExecutor's core pool size.
	 * Default is 1.
	 * <p><b>This setting can be modified at runtime, for example through JMX.</b>
	 */
	public void setCorePoolSize(int corePoolSize) {
		synchronized (this.poolSizeMonitor) {
			this.corePoolSize = corePoolSize;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setCorePoolSize(corePoolSize);
			}
		}
	}

	/**
	 * Return the ThreadPoolExecutor's core pool size.
	 */
	public int getCorePoolSize() {
		synchronized (this.poolSizeMonitor) {
			return this.corePoolSize;
		}
	}

看到我们熟悉的ThreadPoolExecutor之后,我们瞬间明白了一切。

另外我们脑补下几个接口/类的关系

public interface ExecutorService extends Executor {
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
}

public interface Executor {
    void execute(Runnable command);
}

public abstract class AbstractExecutorService implements ExecutorService{
  public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
    // ...
  }
}

public class ThreadPoolExecutor extends AbstractExecutorService {
  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
}

 

© 著作权归作者所有

javahongxi
粉丝 168
博文 259
码字总数 779422
作品 0
朝阳
程序员
私信 提问
Java并发编程原理与实战六:主线程等待子线程解决方案

本文将研究的是主线程等待所有子线程执行完成之后再继续往下执行的解决方案 public class TestThread extends Thread { } 首先是一个线程,它执行完成需要5秒。 1、主线程等待一个子线程 pu...

pony1223
2018/07/23
0
0
Python中的多线程编程实例教程

前言: 线程是操作系统能够进行运算调度的最小单位(程序执行流的最小单元) 它被包含在进程之中,是进程中的实际运作单位 一个进程中可以并发多个线程每条线程并行执行不同的任务 (线程是进...

Code for need ,Code for fun
2018/07/27
0
0
CountDownLatch使用

分享牛原创,CountDownLatch类的使用,CountDownLatch是一个工具类,运行主线程开启子线程的时候,子线程还没有结束的时候,主线程可以一直等待,直到初始化的现成的计数器count为0,主线程就...

分享达人
2016/05/09
0
0
Java编程的逻辑 -- 并发章 -- 线程的基本协作机制

线程的基本协作 线程的基本协作示例 总结 线程的基本协作 多线程间除了竞争访问同一资源外,也经常需要相互协作的去执行一些任务。而对于协作的基本机制用的最多的无疑是wait/notify。 协作的...

HikariCP
2018/06/22
0
0
Java 如何实现线程间通信?

正常情况下,每个子线程完成各自的任务就可以结束了。不过有的时候,我们希望多个线程协同工作来完成某个任务,这时就涉及到了线程间通信了。 本文涉及到的知识点: thread.join(), object....

颖辉小居
2018/12/14
23
2

没有更多内容

加载失败,请刷新页面

加载更多

Handler简解

Handler 这里简化一下代码 以便理解 Handler不一定要在主线程建 但如Handler handler = new Handler(); 会使用当前的Looper的, 由于要更新UI 所以最好在主线程 new Handler() { mLooper = Lo...

shzwork
3分钟前
0
0
h5获取摄像头拍照功能

完整代码展示: <!DOCTYPE html> <head> <title>HTML5 GetUserMedia Demo</title> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum......

诗书易经
6分钟前
0
0
正向代理和反向代理

文章来源 运维公会:正向代理和反向代理 1、正向代理 (1)服务对象不同 正向代理服务器的服务对象是客户端,可以将客户端和代理服务器看作一个整体。 (2)配置方法不同 需要在客户端配置代...

运维团
22分钟前
2
0
5个避免意外论文重复率高的方法

即使你不是故意抄袭,但你可能在无意中抄袭了别人的论文, 这个叫做意外抄袭,它可能正发生在你身上,如果你不熟悉学术 道德规范,这里将告诉你5个基本的方法来避免意外抄袭。 Tip1 熟悉其他...

论文辅导员
23分钟前
2
0
Maven通过profiles标签读取不同的配置

<profiles> <profile> <id>dev</id> <properties> <profiles.active>dev</profiles.active> </properties> ......

时刻在奔跑
29分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部