J.U.C-其他组件-CSDN博客

J.U.C-其他组件

FutureTask

介绍Callable时我们知道它可以有返回值，返回值通过Future进行封装。FutrueTask实现了RunnableFuture接口，该接口继承了Runnable和Future接口，这使得FutureTask既可以当做一个任务执行，也可以有返回值。

FutureTask<T>implements RunnableFuture<t>

interface RunnableFuture <T>extends Runnable,Future<t>

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskExemple {
    public static void main(String[]args)throws InterruptedException, ExecutionException {
        FutureTask<Integer> futureTask=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result=0;
                for(int i=0;i<100;i++){
                    result=result+i;
                    Thread.sleep(10);
                }
                return result;
            }
        });
        Thread computeThread=new Thread(futureTask);
        computeThread.start();
        Thread otherThread=new Thread(()->{
            System.out.println("other Thread is running");
            try{
                Thread.sleep(100);
            }catch (Exception e){
                e.printStackTrace();
            }
        });
        otherThread.start();
        System.out.println(futureTask.get());
    }
}

FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。

BlockingQueue

java.util.concurrent.BlockingQueue接口有以下阻塞队列实现。

（1）FIFO 队列：LinkedBlockingQueue，ArrayBlockingQueue（长度固定）

（2）优先队列：PriorityBlockingQueue

提供了阻塞的take()方法和put()方法：如果队列为空take()将阻塞，知道队列中有内容。如果队列满的话，put()就会阻塞，直到队列中有空的位置。

使用BlockingQueue实现生产者消费者问题

package ConcurrentExemple;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExemple {
    public static BlockingQueue<String>queue= new ArrayBlockingQueue<>(5);
    public static class Consumer extends Thread{
        @Override
        public void run(){
            try {
                String product=queue.take();
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"comsume..");
        }
    }
    public  static class Producer extends Thread{
        @Override
        public void run(){
            try {
                queue.put("product");
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"produce..");
        }
    }
    public static void main(String[]args){
        for(int i=0;i<2;i++){
            Producer producer=new Producer();
            producer.start();
        }
        for(int i=0;i<5;i++){
            Consumer consumer=new Consumer();
            consumer.start();
        }
        for(int i=0;i<3;i++){
            Producer producer=new Producer();
            producer.start();
        }

    }
}

Thread-1produce..
Thread-7produce..
Thread-5comsume..
Thread-4comsume..
Thread-2comsume..
Thread-6comsume..
Thread-3comsume..
Thread-8produce..
Thread-0produce..
Thread-9produce..

ForkJoin

主要用于并行计算中，与MapReduce原理类似，都是把大的计算任务拆分成多个小的任务并行计算。

package ConcurrentExemple;

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

public class ForkJoinExemple {
    public static class ForkExemple extends RecursiveTask<Integer>{
        private final int threshold=5;
        private int first;
        private int last;
        public ForkExemple(int first,int last){
            this.first=first;
            this.last=last;
        }
        @Override
        public Integer compute(){
            int result=0;
            if(last-first<threshold){
                for(int i=first;i<last;i++){
                    result=result+i;
                }
            }else{
                int mid=(first+last)/2;
                ForkExemple leftExemple=new ForkExemple(first,mid);
                ForkExemple rigtExemple=new ForkExemple(mid+1,last);
                leftExemple.fork();
                rigtExemple.fork();
                result=leftExemple.join()+rigtExemple.join();

            }
            return result;
        }
    }
    public static void main(String[]args)throws ExecutionException ,InterruptedException{
        ForkExemple forkExemple=new ForkExemple(1,10000);
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        Future result=forkJoinPool.submit(forkExemple);
        System.out.println(result.get());
    }
}

ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。

public class ForkJoinPool extends AbstractExecutorService

ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。Thread2从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。

转载于:https://www.cnblogs.com/yjxyy/p/10728551.html