Java并发编程

最新推荐文章于 2024-12-30 17:11:38 发布

LittleSkey

最新推荐文章于 2024-12-30 17:11:38 发布

阅读量447

点赞数

CC 4.0 BY-SA版权

分类专栏： Java开发文章标签： java 并发

本文链接：https://blog.youkuaiyun.com/LittleSkey/article/details/53336172

Java开发专栏收录该内容

39 篇文章

订阅专栏

本文介绍了三种常用的Java并发编程技巧：使用CountDownLatch协调线程同步、利用Callable与Future获取异步任务结果、采用ForkJoinPool执行分治算法。通过具体示例展示了如何在实际应用中运用这些技术。

一、利用CountDownLatch

1、类说明

CountDownLatch是JAVA 1.5提供在java.util.concurrent包下的一个辅助类，可以把它看成是一个计数器，其内部维护着一个count计数，只不过对这个计数器的操作都是原子操作，同时只能有一个线程去操作这个计数器，CountDownLatch通过构造函数传入一个初始计数值，调用者可以通过调用CounDownLatch对象的countDown()方法，来使计数减1；如果调用对象上的await()方法，那么调用者就会一直阻塞在这里，直到别人通过countDown方法，将计数减到0，才可以继续执行。

2、示例

package com.learn.thread;

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

public class CountDownThread {

	public static void main(String[] args) throws InterruptedException {
		CountDownThread.demo();
	}
	
	private static int count = 10;
	
      // 初始值决定CountDownLatch类需要等待的事件的数量
	private static CountDownLatch countDownLatch = new CountDownLatch(count);
	
	private static ExecutorService executor = Executors.newFixedThreadPool(count);
	
	public static void demo() throws InterruptedException
	{
		
		for(int i=0;i<count;i++)
		{
			Runnable task = new Task(countDownLatch);
			
			executor.execute(task);
		}
		
		// 等待所有子线程执行结束
		countDownLatch.await();
		
		executor.shutdown();
		
		System.out.println("主线程结束");
		
	}
	
}

class Task implements Runnable 
{
	private CountDownLatch countDownLatch;
	
	private static int num = 0;
	
	public Task(CountDownLatch countDownLatch)
	{
		this.countDownLatch = countDownLatch;
	}
	
	public void run() 
	{
		System.out.println("子线程执行");

		// 实现逻辑
		synchronized (Task.class) {
			System.out.println("num:" + num);
			num++;
		}

		System.out.println("剩余线程:" + countDownLatch.getCount());
		
		// 必须等处理逻辑处理完成后才能减1
		countDownLatch.countDown();
		

	}
}

二、利用Callable、Future和FutureTask

1、类说明

（1）Callable与Future是Java在后续版本中为了适应多并发加入的，Callable是类似于Runnable的接口，都可被其他线程执行的任务。主要区别：

Callable定义的方法是call，而Runnable定义的方法是run。
Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。
Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。

（2）Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

主要方法：

cancel：方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
isCancelled：方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone：方法表示任务是否已经完成，若任务完成，则返回true。
get()：方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回。
get(long timeout, TimeUnit unit)：用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

（3）FutureTask实现了RunnableFuture接口，RunnableFuture继承了Runnable、Future接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

2、示例

任务类：

// 测试任务类
class testCallable implements Callable<Integer> 
{

	public Integer call() throws Exception {
		
		System.out.println("子线程开始");
		
		Thread.sleep(1000);
		
		return 1;
	}
	
}

Future实现：

package com.learn.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureThread {

	public static void demo()
	{
		ExecutorService executor = Executors.newCachedThreadPool();
		
		Future<Integer> future = executor.submit(new testCallable());
		executor.shutdown();
		
		System.out.println("主线程继续执行");
		
		try {
			System.out.println("子线程结果："+ future.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("主线程结束");
	}
	
	
	public static void main(String[] args) {
		FutureThread.demo();
	}
}

FutureTask实现：

package com.learn.thread;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskThread {

	public static void demo()
	{
		ExecutorService executor = Executors.newCachedThreadPool();
		
		FutureTask<Integer> futuretask = new FutureTask<Integer>(new testCallable());
		executor.submit(futuretask);
		executor.shutdown();
		
		System.out.println("主线程运行中");
		
		try {
			System.out.println("子线程结果：" + futuretask.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		FutureTask<Integer> futuretask2 = new FutureTask<Integer>(new testCallable());
		Thread thread = new Thread(futuretask2);
		thread.start();
		
		System.out.println("主线程运行中2");
		
		try {
			System.out.println("子线程2结果：" + futuretask2.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		System.out.println("主线程结束");
		
	}
	
	
	public static void main(String[] args) {
		FutureTaskThread.demo();
	}
	
}

三、利用ForkJoinPool

1、类说明

jdk7新增了并发框架fork/join框架，在这种框架下，ForkJoinTask代表一个需要执行的任务，真正执行这些任务的线程是放在一个线程池（ForkJoinPool）里面。
ForkJoinPool就是一个ExcuteService，ForkJoinPool除了可以执行Runnable任务外，还可以执行ForkJoinTask任务。与ExcuteService不同的是它采用了work-stealing模式。

work-stealing算法:

work-stealing 是一种任务调度方法，由多个工作线程组成，每个工作线程用一个双端队列维护一组任务。Fork的时候是把任务加到队列的头部，而不像一般的线程池那样是加到任务队列末尾。工作线程选择头部最新的任务来执行。当工作线程没有任务可执行时，它会尝试从其它线程的任务队列尾部窃取一个任务执行。如果没有任务执行了并且窃取其它任务失败，那么工作线程停止。
这种方法的优点是减少了争用，因为工作线程从头获取任务，而窃取线程从尾部窃取任务。另一个优点是递归的分治法使得早期产生的是较大的任务单元，而窃取到较大任务会进一步递归分解，因此也减少了尾部窃取的次数。另外，父任务很可能要等待子任务（join），所以从队列头部子任务开始执行也是一种优化。

2、示例：

package com.learn.thread;

import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

// 计算斐波那契数列
public class Fibonacci extends RecursiveTask<BigInteger> {

	private static final long serialVersionUID = 1L;
	
	int n;

	public Fibonacci() {
	}

	Fibonacci(int i) {
		this.n = i;
	}

	private BigInteger compute(int small) {
		final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
		return new BigInteger(results[small] + "");
	}

	@Override
	protected BigInteger compute() {
		// 任务足够小,直接查表返回
		if (n < 10) { 
			return compute(n);
		}
		
		System.out.println(Thread.currentThread().getName() + "");
		// 创建子任务
		Fibonacci f1 = new Fibonacci(n - 1);
		Fibonacci f2 = new Fibonacci(n - 2);
		
		// 子任务执行
		f2.fork();
		
		// 两个子任务结果的合并。f2.join()获取结果
		return f1.compute().add(f2.join());
	}

	public static void main(String[] args) {
		/* 线程的数量有限,超过一定的数量会报错,内存溢出 */
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		// 创建任务
		Fibonacci fibonacci = new Fibonacci(20);
		Future<BigInteger> result = forkJoinPool.submit(fibonacci);
		try {
			System.out.println(result.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}