java并行执行多个任务

java并行执行多个任务:

最近做项目中,有个任务需要实现并发编程,个人参考了下网上的实现,自己实现了下并发方法,并且增加了简单的说明,希望的有需要的朋友有些帮助。


 
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 测试监控类
 * 
 * @author
 * 
 */
public class WatchThread {
	
	private String name = UUID.randomUUID().toString();

	/**
	 * 测试函数
	 * 
	 * @throws InterruptedException
	 */
	public void testThread() throws InterruptedException {
		int threadNum = 10;
		// 初始化countDown
		CountDownLatch threadSignal = new CountDownLatch(threadNum);
		// 创建固定长度的线程池
//		Executor executor = Executors.newFixedThreadPool(threadNum);
		//此处不可以用接口 需要使用Executor的实现类 ExecutorService  Executor未提供shutdown等方法
		ExecutorService executor = Executors.newFixedThreadPool(threadNum);
		for (int i = 0; i < threadNum; i++) { // 开threadNum个线程
			Runnable task = new TestThread(threadSignal);
			// 执行
			executor.execute(task);
			
		}
		threadSignal.await(); // 等待所有子线程执行完
		//固定线程池执行完成后 将释放掉资源 退出主进程
		executor.shutdown();//并不是终止线程的运行,而是禁止在这个Executor中添加新的任务
		// do work end
		//退出主进程
		System.out.println(Thread.currentThread().getName() + "+++++++结束.");
	}

	/**
	 * 测试函数
	 */
	public static void main(String[] args) throws InterruptedException {
		WatchThread test = new WatchThread();
		test.testThread();
	}

	/**
	 * 
	 * @author wangmuming
	 * 此可以做完内部类 也可以不做未内部类
	 * 作为内部类的时候 有一个好处 就是可以直接引用给类的主对象的成员变量 如此处的name
	 * 当然
	 */
	private class TestThread implements Runnable {
		private CountDownLatch threadsSignal;

		public TestThread(CountDownLatch threadsSignal) {
			this.threadsSignal = threadsSignal;
		}
		

		public void run() {
			System.out.println(Thread.currentThread().getName() + "开始..." + name);
			System.out.println("开始了线程::::" + threadsSignal.getCount());
			
			// do shomething
		
			//核心处理逻辑
			
		//	用到成员变量name作为参数
			
			// 线程结束时计数器减1
			threadsSignal.countDown();//必须等核心处理逻辑处理完成后才可以减1
			System.out.println(Thread.currentThread().getName() + "结束. 还有"
					+ threadsSignal.getCount() + " 个线程");
		}
	}

}



执行结果:


pool-1-thread-1开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::10
pool-1-thread-1结束. 还有9 个线程
pool-1-thread-2开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::9
pool-1-thread-2结束. 还有8 个线程
pool-1-thread-3开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::8
pool-1-thread-3结束. 还有7 个线程
pool-1-thread-4开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
pool-1-thread-5开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::7
开始了线程::::7
pool-1-thread-4结束. 还有6 个线程
pool-1-thread-5结束. 还有5 个线程
pool-1-thread-10开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::5
pool-1-thread-6开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
pool-1-thread-9开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::4
pool-1-thread-9结束. 还有3 个线程
pool-1-thread-8开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::3
pool-1-thread-8结束. 还有2 个线程
pool-1-thread-7开始...aaa917dc-bd69-4438-9bb1-0051e5c62984
开始了线程::::2
pool-1-thread-7结束. 还有1 个线程
开始了线程::::4
pool-1-thread-10结束. 还有4 个线程
pool-1-thread-6结束. 还有0 个线程
main+++++++结束.

### Java 中的任务并行执行 #### 使用 `CompletableFuture` 实现并行任务Java中,可以利用`CompletableFuture`来实现多个方法的并行执行。这种方式非常适合用于那些需要等待不同来源的数据完成后再做进一步处理的情形。 ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class CompletableFutureExample { public static void main(String[] args) throws InterruptedException, ExecutionException { // 创建三个独立运行的方法作为异步任务 CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> methodOne()); CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> methodTwo()); CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> methodThree()); // 当所有任务都完成后继续执行后续逻辑 CompletableFuture.allOf(future1, future2, future3).join(); System.out.println("All methods have completed."); } private static void methodOne() { /* 方法体 */ } private static void methodTwo() { /* 方法体 */ } private static void methodThree() { /* 方法体 */ } } ``` 此代码片段展示了如何创建三个并发执行的任务,并通过`allOf()`方法确保只有当这三个任务全部结束之后才会打印消息[^2]。 #### 利用并行流 (`parallelStream`) 对于集合类对象的操作,如果希望这些操作能够被自动分配到不同的线程上以提高效率,则可以选择使用并行流来进行遍历或其他形式的数据处理工作。 ```java import java.util.Arrays; import java.util.List; public class ParallelStreamExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 对列表中的元素应用某种函数式的转换过程,在这里只是简单地乘以2 numbers.parallelStream().map(n -> n * 2).forEach(System.out::println); } } ``` 这段程序会把给定整数列表里的每一个数值翻倍,并且由于采用了并行模式所以理论上可以在多核CPU环境下获得更好的性能表现[^4]。 #### 借助 `ExecutorService` 和 `Future` 另一种常见的做法就是借助于`ExecutorService`接口所提供的功能去管理一组可重用的工作线程池;与此同时还可以配合`Future`接口获取由各个子任务返回的结果值。 ```java import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; class Task implements Callable<String> { @Override public String call() throws Exception { Thread.sleep((long)(Math.random()*1000)); return "Task executed"; } } public class ExecutorServiceExample { public static void main(String[] args) throws Exception{ int numberOfTasks = 3; // 定义要启动的任务数量 ExecutorService executor = Executors.newFixedThreadPool(numberOfTasks); List<Future<String>> futures = new ArrayList<>(); for (int i=0;i<numberOfTasks;i++){ Future<String> result = executor.submit(new Task()); futures.add(result); } for(Future<String> f :futures){ System.out.println(f.get()); // 获取每个任务的结果 } executor.shutdown(); // 关闭服务 } } ``` 上述例子说明了怎样设置固定大小的线程池来提交一批相似性质的小型作业,并收集它们各自的输出信息.
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值