Java线程的并发工具类

最新推荐文章于 2024-01-20 17:41:10 发布
最新推荐文章于 2024-01-20 17:41:10 发布
阅读量520 收藏 1
点赞数 2
分类专栏： Java筑基 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbsssss/article/details/127156118
版权

Fork-Join

java 下多线程的开发可以我们自己启用多线程，线程池，还可以使用 forkjoin，forkjoin 可以让我们不去了解诸如 Thread,Runnable 等相关的知识，只要遵循forkjoin 的开发模式，就可以写出很好的多线程并发程序。

分而治之

分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。计算机十大经典算法中二分查找、快速排序、归并排序都是分而治之的思想。
分治策略是：对于一个规模为 n 的问题，若该问题可以容易地解决（比如说规模 n 较小）则直接解决，否则将其分解为 k 个规模较小的子问题，这些子问题互相独立且与原问题形式相同(子问题相互之间有联系就会变为动态规范算法)，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，称为 2路归并，与之对应的还有多路归并。
对于给定的一组数据，利用递归与分治技术将数据序列划分成为越来越小的半子表，在对半子表排序后，再用递归方法将排好序的半子表合并成为越来越大的有序序列。
为了提升性能，有时我们在半子表的个数小于某个数的情况下，对半子表的排序采用其他排序算法，比如插入排序。

归并排序（降序）示例

在这里插入图片描述
在这里插入图片描述

大数据中的分而治之

在这里插入图片描述

Fork-Join原理

在这里插入图片描述

工作密取

即当前线程的 Task 已经全被执行完毕，则自动取到其他线程的 Task 池中取出 Task 继续执行。
ForkJoinPool 中维护着多个线程（一般为 CPU 核数）在不断地执行 Task，每个线程除了执行自己职务内的 Task 之外，还会根据自己工作线程的闲置情况去获取其他繁忙的工作线程的 Task，如此一来就能能够减少线程阻塞或是闲置的时间，提高 CPU 利用率。
在这里插入图片描述

Fork/Join 实战

Fork/Join使用的标准范式

我们要使用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它提供在任务中执行 fork 和 join 的操作机制，通常我们不直接继承 ForkjoinTask 类，只需要直接继承其子类。

  1. RecursiveAction，用于没有返回结果的任务
  2. RecursiveTask，用于有返回值的任务

task 要通过 ForkJoinPool 来执行，使用 submit 或 invoke 提交，两者的区别是：invoke 是同步执行，调用之后需要等待任务完成，才能执行后面的代码；submit 是异步执行。
join()和 get 方法当任务完成的时候返回计算结果。
在这里插入图片描述
在我们自己实现的 compute 方法里，首先需要判断任务是否足够小，如果足够小就直接执行任务。如果不足够小，就必须分割成两个子任务，每个子任务在调用 invokeAll 方法时，又会进入 compute 方法，看看当前子任务是否需要继续分割成孙任务，如果不需要继续分割，则执行当前子任务并返回结果。使用join方法会等待子任务执行完并得到其结果

Fork/Join的同步用法和异步用法

在这里插入图片描述

同步用法（统计整形数组中所有元素的和）

首先我们有一个随机数组生成器：

public class MakeArray {
    //数组长度
    public static final int ARRAY_LENGTH  = 4000;
    public final static int THRESHOLD = 47;

    public static int[] makeArray() {

        //new一个随机数发生器
        Random r = new Random();
        int[] result = new int[ARRAY_LENGTH];
        for(int i=0;i<ARRAY_LENGTH;i++){
            //用随机数填充数组
            result[i] =  r.nextInt(ARRAY_LENGTH*3);
        }
        return result;

    }
}

当我们用单线程执行累加：

/**
 * 单线程执行累加
 */
public class SumNormal {
	
	public static void main(String[] args) {
	    int count = 0;
	    int[] src = MakeArray.makeArray();

	    long start = System.currentTimeMillis();
	    for(int i= 0;i<src.length;i++){
			SleepTools.ms(1);
	    	count = count + src[i];
	    }
	    System.out.println("The count is "+count
	            +" spend time:"+(System.currentTimeMillis()-start)+"ms");		
	}

}

在这里插入图片描述
ForkJoin执行累加：

/**
 * ForkJoin执行累加
 */
public class SumArray {
    private static class SumTask extends RecursiveTask<Integer>{

        /*阈值*/
        private final static int THRESHOLD = MakeArray.ARRAY_LENGTH/10;
        private int[] src;
        private int fromIndex;
        private int toIndex;

        public SumTask(int[] src, int fromIndex, int toIndex) {
            this.src = src;
            this.fromIndex = fromIndex;
            this.toIndex = toIndex;
        }

        @Override
        protected Integer compute() {
            /*任务的大小是否合适*/
            if (toIndex - fromIndex < THRESHOLD){
//                System.out.println(" from index = "+fromIndex
//                        +" toIndex="+toIndex);
                int count = 0;
                for(int i= fromIndex;i<=toIndex;i++){
                	SleepTools.ms(1);
                     count = count + src[i];
                }
                return count;
            }else{
                //fromIndex....mid.....toIndex
                int mid = (fromIndex+toIndex)/2;
                SumTask left = new SumTask(src,fromIndex,mid);
                SumTask right = new SumTask(src,mid+1,toIndex);
                invokeAll(left,right);
                return left.join()+right.join();
            }
        }
    }


    public static void main(String[] args) {

        int[] src = MakeArray.makeArray();
        /*new出池的实例*/
        ForkJoinPool pool = new ForkJoinPool();
        /*new出Task的实例*/
        SumTask innerFind = new SumTask(src,0,src.length-1);

        long start = System.currentTimeMillis();

        pool.invoke(innerFind);
        //System.out.println("Task is Running.....");

        System.out.println("The count is "+innerFind.join()
                +" spend time:"+(System.currentTimeMillis()-start)+"ms");

    }
}

在这里插入图片描述

异步用法（遍历指定目录寻找指定类型的文件）
/**
 *类说明：遍历指定目录（含子目录）找寻指定类型文件
 */
public class FindDirsFiles extends RecursiveAction {

    private File path;

    public FindDirsFiles(File path) {
        this.path = path;
    }

    @Override
    protected void compute() {
        List<FindDirsFiles> subTasks = new ArrayList<>();

        File[] files = path.listFiles();
        if (files!=null){
            for (File file : files) {
                if (file.isDirectory()) {
                    // 对每个子目录都新建一个子任务。
                    subTasks.add(new FindDirsFiles(file));
                } else {
                    // 遇到文件，检查。
                    if (file.getAbsolutePath().endsWith("txt")){
                        System.out.println("文件:" + file.getAbsolutePath());
                    }
                }
            }
            if (!subTasks.isEmpty()) {
                // 在当前的 ForkJoinPool 上调度所有的子任务。
                for (FindDirsFiles subTask : invokeAll(subTasks)) {
                    subTask.join();
                }
            }
        }
    }

    public static void main(String [] args){
        try {
            // 用一个 ForkJoinPool 实例调度总任务
            ForkJoinPool pool = new ForkJoinPool();
            FindDirsFiles task = new FindDirsFiles(new File("D:/"));

            /*异步提交*/
            pool.execute(task);

            /*主线程做自己的业务工作*/
            System.out.println("Task is Running......");
            Thread.sleep(1);
            int otherWork = 0;
            for(int i=0;i<100;i++){
                otherWork = otherWork+i;
            }
            System.out.println("Main Thread done sth......,otherWork="
                    +otherWork);
            task.join();//阻塞方法
            System.out.println("Task end");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

CountDownLatch

闭锁，CountDownLatch 这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
CountDownLatch 是通过一个计数器来实现的，计数器的初始值为初始任务的数量。每当完成了一个任务后，计数器的值就会减 1（CountDownLatch.countDown()方法）。当计数器值到达 0 时，它表示所有的已经完成了任务，然后在闭锁上等待 CountDownLatch.await()方法的线程就可以恢复执行任务。
应用场景：
实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为 1 的 CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次 countDown()方法就可以让所有的等待线程同时恢复执行。
开始执行前等待 n 个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有 N 个外部系统已经启动和运行了，例如处理 excel 中多个表单。
在这里插入图片描述
代码示例：

/**
 *类说明：演示CountDownLatch用法，
 * 共5个初始化子线程，6个闭锁扣除点，扣除完毕后，主线程和业务线程才能继续执行
 */
public class UseCountDownLatch {
	
    static CountDownLatch latch = new CountDownLatch(6);

    /*初始化线程*/
    private static class InitThread implements Runnable{

        public void run() {
        	System.out.println("Thread_"+Thread.currentThread().getId()
        			+" ready init work......");
            latch.countDown();
            for(int i =0;i<2;i++) {
            	System.out.println("Thread_"+Thread.currentThread().getId()
            			+" ........continue do its work");
            }
        }
    }

    /*业务线程等待latch的计数器为0完成*/
    private static class BusiThread implements Runnable{

        public void run() {
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for(int i =0;i<3;i++) {
            	System.out.println("BusiThread_"+Thread.currentThread().getId()
            			+" do business-----");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            public void run() {
            	SleepTools.ms(1);
                System.out.println("Thread_"+Thread.currentThread().getId()
            			+" ready init work step 1st......");
                latch.countDown();
                System.out.println("begin step 2nd.......");
                SleepTools.ms(1);
                System.out.println("Thread_"+Thread.currentThread().getId()
            			+" ready init work step 2nd......");
                latch.countDown();
            }
        }).start();
        new Thread(new BusiThread()).start();
        for(int i=0;i<=3;i++){
            Thread thread = new Thread(new InitThread());
            thread.start();
        }

        latch.await();
        System.out.println("Main do ites work........");
    }
}

在这里插入图片描述

CyclicBarrier

在这里插入图片描述
代码示例：
演示CyclicBarrier用法,共5个子线程，他们全部完成工作后，交出自己结果，再被统一释放去做自己的事情，而交出的结果被另外的线程拿来拼接字符串

/**
 *类说明：演示CyclicBarrier用法,共5个子线程，他们全部完成工作后，交出自己结果，
 *再被统一释放去做自己的事情，而交出的结果被另外的线程拿来拼接字符串
 */
public class UseCyclicBarrier {
    private static CyclicBarrier barrier=new CyclicBarrier(4,new CollectThread());
    private static ConcurrentHashMap<String,Long> resultMap
            = new ConcurrentHashMap<>();//存放子线程工作结果的容器

    public static void main(String[] args) {
        for(int i=0;i<=4;i++){
            Thread thread = new Thread(new SubThread());
            thread.start();
        }

    }

    private static class CollectThread implements Runnable{

        @Override
        public void run() {
            StringBuilder result = new StringBuilder();
            for(Map.Entry<String,Long> workResult:resultMap.entrySet()){
            	result.append("["+workResult.getValue()+"]");
            }
            System.out.println(" the result = "+ result);
            System.out.println("do other business........");
        }
    }

    private static class SubThread implements Runnable{

        @Override
        public void run() {
        	long id = Thread.currentThread().getId();
            resultMap.put(Thread.currentThread().getId()+"",id);
            Random r = new Random();
            try {
                	Thread.sleep(1000+id);
                	System.out.println("Thread_"+id+" ....do something ");
                barrier.await();
            	Thread.sleep(1000+id);
                System.out.println("Thread_"+id+" ....do its business ");
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

在这里插入图片描述
CyclicBarrier可以反复调用，CountDownLatch不行。CountDownLatch是由外面线程来协调，CyclicBarrier是通过工作线程本身相互协调的。CyclicBarrier和线程数密切相关，CountDownLatch没有。CyclicBarrier可以进行汇总，CountDownLatch不行。实际工作中，我们对CountDownLatch可能用的更多。

Semaphore

主要用于流控场景
在这里插入图片描述

用Semaphore实现数据库连接池

/**
 *类说明：数据库连接的平庸实现
 */
public class SqlConnectImpl implements Connection{
	
	/*拿一个数据库连接*/
    public static final Connection fetchConnection(){
        return new SqlConnectImpl();
    }

/**
 *类说明：演示Semaphore用法，一个数据库连接池的实现
 */
public class DBPoolSemaphore {
	
	private final static int POOL_SIZE = 10;
	//两个指示器，分别表示池子还有可用连接和已用连接
	private final Semaphore useful,useless;
	//存放数据库连接的容器
	private static LinkedList<Connection> pool = new LinkedList<Connection>();
	//初始化池
	static {
        for (int i = 0; i < POOL_SIZE; i++) {
            pool.addLast(SqlConnectImpl.fetchConnection());
        }
	}
	public DBPoolSemaphore() {
		this.useful=new Semaphore(10);
		this.useless=new Semaphore(0);
	}
	
	/*归还连接*/
	public void returnConnect(Connection connection) throws InterruptedException {
		if(connection!=null) {
			System.out.println("当前有"+useful.getQueueLength()+"个线程等待数据库连接!!"
					+"可用连接数："+useful.availablePermits());
			useless.acquire();
			synchronized (pool) {
				pool.addLast(connection);
			}
			useless.release();
		}
	}
	
	/*从池子拿连接*/
	public Connection takeConnect() throws InterruptedException {
		useful.acquire();
		Connection connection;
		synchronized (pool) {
			connection = pool.removeFirst();
		}
		useless.release();
		return connection;
	}
	
}


/**
 *类说明：测试数据库连接池
 */
public class AppTest {

	private static DBPoolSemaphore dbPool = new DBPoolSemaphore();
	
	private static class BusiThread extends Thread{
		@Override
		public void run() {
			Random r = new Random();//让每个线程持有连接的时间不一样
			long start = System.currentTimeMillis();
			try {
				Connection connect = dbPool.takeConnect();
				System.out.println("Thread_"+Thread.currentThread().getId()
						+"_获取数据库连接共耗时【"+(System.currentTimeMillis()-start)+"】ms.");
				SleepTools.ms(100+r.nextInt(100));//模拟业务操作，线程持有连接查询数据
				System.out.println("查询数据完成，归还连接！");
				dbPool.returnConnect(connect);
			} catch (InterruptedException e) {
			}
		}
	}
	
	public static void main(String[] args) {
        for (int i = 0; i < 50; i++) {
            Thread thread = new BusiThread();
            thread.start();
        }
	}
	
}

在这里插入图片描述

Semaphore注意事项：

如果我们没有使用Useless，则无法实现对数据库的总连接数的限制，因为我们每次都是new:

/**
 *类说明：演示Semaphore用法，一个数据库连接池的实现
 */
public class DBPoolNoUseless {

	private final static int POOL_SIZE = 10;
	private final Semaphore useful;
	//存放数据库连接的容器
	private static LinkedList<Connection> pool = new LinkedList<Connection>();
	//初始化池
	static {
        for (int i = 0; i < POOL_SIZE; i++) {
            pool.addLast(SqlConnectImpl.fetchConnection());
        }
	}
	public DBPoolNoUseless() {
		this.useful = new Semaphore(10);
	}
	
	/*归还连接*/
	public void returnConnect(Connection connection) throws InterruptedException {
		if(connection!=null) {
			System.out.println("当前有"+useful.getQueueLength()+"个线程等待数据库连接!!"
					+"可用连接数："+useful.availablePermits());
			synchronized (pool) {
				pool.addLast(connection);
			}
			useful.release();
		}
	}
	
	/*从池子拿连接*/
	public Connection takeConnect() throws InterruptedException {
		useful.acquire();
		Connection connection;
		synchronized (pool) {
			connection = pool.removeFirst();
		}
		return connection;
	}

	private static DBPoolNoUseless dbPoolNoUseless = new DBPoolNoUseless();

	private static class BusiThread extends Thread{
		@Override
		public void run() {
			Random r = new Random();//让每个线程持有连接的时间不一样
			long start = System.currentTimeMillis();
			try {
				System.out.println("Thread_"+Thread.currentThread().getId()
						+"_获取数据库连接共耗时【"+(System.currentTimeMillis()-start)+"】ms.");
				SleepTools.ms(100+r.nextInt(100));//模拟业务操作，线程持有连接查询数据
				System.out.println("查询数据完成，归还连接！");
				dbPoolNoUseless.returnConnect(new SqlConnectImpl());
			} catch (InterruptedException e) {
			}
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 50; i++) {
			Thread thread = new BusiThread();
			thread.start();
		}
	}
	
}

在这里插入图片描述

Exchange

在这里插入图片描述

/**
 *类说明：演示CyclicExchange用法
 */
public class UseExchange {
    private static final Exchanger<Set<String>> exchange = new Exchanger<Set<String>>();

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
            	Set<String> setA = new HashSet<String>();//存放数据的容器
                try {
                	/*添加数据
                	 * set.add(.....)
                	 * */
                	setA = exchange.exchange(setA);//交换set
                	/*处理交换后的数据*/
                } catch (InterruptedException e) {
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
            	Set<String> setB = new HashSet<String>();//存放数据的容器
                try {
                	/*添加数据
                	 * set.add(.....)
                	 * set.add(.....)
                	 * */
                	setB = exchange.exchange(setB);//交换set
                	/*处理交换后的数据*/
                } catch (InterruptedException e) {
                }
            }
        }).start();

    }
}

Callable、Future和FutureTask

在这里插入图片描述

/**
 *类说明：演示Future等的使用
 */
public class UseFuture {
	
	
	/*实现Callable接口，允许有返回值*/
	private static class UseCallable implements Callable<Integer>{
		private int sum;
		@Override
		public Integer call() throws Exception {
			System.out.println("Callable子线程开始计算！");  
			Thread.sleep(2000);
	        for(int i=0 ;i<5000;i++){  
	            sum=sum+i;  
	        }  
	        System.out.println("Callable子线程计算结束！结果为: "+sum);  
	        return sum; 
		}
	}
	
	public static void main(String[] args) 
			throws InterruptedException, ExecutionException {
		
		UseCallable useCallable = new UseCallable();
		FutureTask<Integer> futureTask //用FutureTask包装Callable
			= new FutureTask<>(useCallable);
		new Thread(futureTask).start();//交给Thread去运行
		Random r = new Random();
		Thread.sleep(1000);
		if(r.nextBoolean()) {//用随机的方式决定是获得结果还是终止任务
			System.out.println("Get UseCallable result = "+futureTask.get());
		}else {
			System.out.println("中断计算。  ");
			futureTask.cancel(true);
		}
		
	}

}

在这里插入图片描述
在这里插入图片描述

gujunhe
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程池任务执行器配置以及ExecutorService的invallkeAll、submit、execute方法的区别
xiaolong2230的博客
12-02 2102
一、任务调度器配置： task:scheduler/@pool-size：调度线程池的大小，调度线程在被调度任务完成前不会空闲 task:scheduled/@cron：cron表达式，注意，若上次任务未完成，即使到了下一次调度时间，任务也不会重复调度 <task:scheduled-tasks scheduler="scheduler"> <task:schedul...
线程池-invokeAll
CWeeYii的专栏
10-16 5482
invokeAllinvoke类方法invokeAll和invokeAny与submit方法方法最大的区别是submit是异步的其不会等待任务的完成，而invoke方法是同步的，其需要等待任务的完成，才能返回public class InvokeAll { private static final Logger LOGGER = LoggerFactory.getLogger(InvokeA
executorService的submit和invokeAll的区别
岛田悠米
08-29 453
【代码】executorService的submit和invokeAll的区别。
Java并发线程池
页页的博客
03-24 2074
线程池 一、为什么要用线程池？ 使用线程池的好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 比较重要的几个类： 类名 描述 ExecutorService 真正的线程池接口。 ScheduledExecutorService 能和Timer/Tim
并发工具类：线程池execute和submit有什么区别
小识的博客
04-09 1608
使用工具类创建线程池 上一节我们已经自己实现了一个线程池，本节我们看看JDK提供的线程池是如何实现的？ public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, .
Java多线程知识汇总（三）
最新发布
haohaizi_liu的专栏
01-20 911
线程池的优势总体来说，线程池有如下的优势：1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
Java线程并发工具类CountDownLatch原理及用法
08-25
总结来说，CountDownLatch和CyclicBarrier都是Java并发编程中的重要工具，它们可以帮助开发者协调多线程间的同步行为。CountDownLatch更适合于一次性使用的场景，用于让一个线程等待其他线程完成特定操作，而...
Java多线程之并发工具类
12-22
Java并发工具类是Java多线程编程中必不可少的一部分，它们为开发者提供了更加高效和灵活的线程同步机制。本文将详细介绍三个重要的并发工具类：CountDownLatch、CyclicBarrier和Semaphore。 首先，CountDownLatch是...
JAVA并发编程-2-线程并发工具类
01-20
JAVA并发编程-2-线程并发工具类一、Fork/Join1、分而治之与工作密取2、使用标准范式3、Fork/Join的同步用法4、Fork/Join的异步用法二、CountDownLatch三、CyclicBarrier四、Semaphore信号量五、Exchanger ...
java线程并发semaphore类示例
09-04
Java 5.0引入了四个新的同步工具类，它们是Semaphore、CountDownLatch、CyclicBarrier和Exchanger，用于解决线程间的同步问题。本篇将重点讲解Semaphore类。 Semaphore，顾名思义，就像是一个信号灯或通行证，用来...
Java并发工具辅助类代码实例
08-19
在Java中，并发工具辅助类是一种非常重要的工具，通过使用这些工具，可以帮助开发者更好地管理多线程，提高程序的性能和可靠性。在本文中，我们将介绍两种重要的并发工具辅助类：CountDownLatch和CyclicBarrier。 ...
请简要说明线程池有哪些方法，方法之间有哪些区别
sinat_40880767的博客
06-27 385
ExecutorService接口方法： 提交方法： execute(Runnable)、submit(Runnable)、submit(Callable)、invokeAny(…)、invokeAll(…)； execute(Runnable)和submit(Runnable)没有返回值，submit(Callable)返回一个Future对象（包装执行结果）。 invokeAny(…)接收一个...
多线程一锅乱炖（Runnable、Callable、Thread、Future、FutureTask、execute、submit、invokeAll、invokeAny）
qq_42078712的博客
08-31 134
FutureTask实现了RunnableFuture接口(Runnable + Future)，相比于同为实现类的Thread，仅仅做到了**(控制进程状态 + 获取结果/状态)**。Thread类实现了Runnable接口，做到了**(新建任务 -> 新建线程 -> 启动线程 -> 控制线程)**全过程。提交后无法判断该任务是否被线程池执行成功。因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。的服务器，为了资源的合理利用，需要限制当前线程数量。
ExecutorService submit VS invoke
michaelforgood的博客
12-05 345
Method submit extends base method Executor.execute(java.lang.Runnable) by creating and returning a Future that can be used to cancel execution and/or wait for completion. Methods invokeAny and invokeA...
Java多线程（ExecutorService 、Executors、Callable、Future、FutureTask）
Kikityer的博客
11-21 468
前言：我们一般通过继承Thread类重写run方法或者实现runnable接口重写run方法，最后创建和启动一个线程，但是都需要自己创建、启动Thread对象。线程池可以实现帮助我们管理Thread对象，至于要使用几个线程，什么时候启动这些线程，是开启多个线程还是用单个线程来完成这些任务，我们无需操心。 Java通过Executors提供四种线程池  newCachedThreadPool...
线程池使用案例：ExecutorService的execute、submit、invokeAll、 invokeAny、shutdown方法
Sold Out
02-05 3310
目录 execute submit invokeAll invokeAny shutdown execute // 执行任务 void execute(Runnable command); @Slf4j(topic = "c.ThreadPoolExecutor")//日志注解，可以使用sout替代 public class ThreadPoolExecutorTest { public static void main(String[] args) { ..
ForkJoinPool invoke、execute和submit区别
Heqianqian的博客
04-09 8402
使用ForkJoinPool的时候发现执行任务的方法有： invoke(ForkJoinTask task) execute(ForkJoinTask<?> task) submit(ForkJoinTask task) 三种方式，现在总结下区别。 首先比较execute和submit的区别，观察源码发现： /** * Arranges for (asynchro...
ForkJoin_invoke_submit_execute
weixin_33998125的博客
05-14 739
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gujunhe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值