并发编程（三）线程池的使用

最新推荐文章于 2022-11-07 16:28:36 发布
最新推荐文章于 2022-11-07 16:28:36 发布
阅读量107 收藏
点赞数
分类专栏： Java并发
原文链接：https://blog.csdn.net/qq_36434742/article/details/106956102
版权

上节部分并发编程（二）

  1. Executor的使用

    import java.util.concurrent.Executor;

public class Demo1_Executor implements Executor {

    public static void main(String[] args) {
        Demo1_Executor demo1_executor = new Demo1_Executor();
        demo1_executor.execute(()-> System.out.println("I am is Executor"));
    }

    @Override
    public void execute(Runnable command) {
        command.run();
    }
}

  2. Callable的使用

    import java.util.concurrent.*;

/*
* 认识Callable,对Runnable进行了扩展，由于重写了，不能抛出异常
* 对Callable的调用，可以有返回值，可以抛出异常
* Runnable没有返回值（最主要的区别）
* */
public class Demo2_Callable implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        return 100;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> submit = executorService.submit(new Demo2_Callable());
        System.out.println(submit.get());
        executorService.shutdown();
    }

}

  3. ThreadPool使用

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

public class Demo3_ThreadPool {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 6; i++) {
            service.execute(()->{
                try {
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());

            });
        }
        System.out.println(service);

        service.shutdown();
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);

        TimeUnit.SECONDS.sleep(5);
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);
    }
}

  4. Future的使用

    import java.util.concurrent.*;

public class Demo4_Future {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(() -> {
            TimeUnit.MICROSECONDS.sleep(500);
            return 1000;
        });

        new Thread(task).start();

        System.out.println(task.get());

        ExecutorService service = Executors.newFixedThreadPool(5);
        Future<Integer> f = service.submit(() -> {
            TimeUnit.MICROSECONDS.sleep(500);
            return 1;
        });

        System.out.println(f.get());
        System.out.println(f.isDone());
    }
}

    import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Demo5_ParalleComputing {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> results = getPrime(1, 200000);
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        final int cupCoreNum = 8;
        ExecutorService executorService = Executors.newFixedThreadPool(cupCoreNum);
        MyTask myTask1 = new MyTask(1, 50000);
        MyTask myTask2 = new MyTask(50001, 100000);
        MyTask myTask3 = new MyTask(100001, 150000);
        MyTask myTask4 = new MyTask(150001, 200000);

        Future<List<Integer>> f1 = executorService.submit(myTask1);
        Future<List<Integer>> f2 = executorService.submit(myTask2);
        Future<List<Integer>> f3 = executorService.submit(myTask3);
        Future<List<Integer>> f4 = executorService.submit(myTask4);

        start = System.currentTimeMillis();
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        end = System.currentTimeMillis();
        System.out.println(end - start);
        executorService.shutdown();

    }

    static class MyTask implements Callable<List<Integer>> {
        int startPos, endPos;

        public MyTask(int startPos, int endPos) {
            this.startPos = startPos;
            this.endPos = endPos;
        }

        @Override
        public List<Integer> call() throws Exception {
            List<Integer> r = getPrime(startPos, endPos);
            return null;
        }

    }

    static boolean isPrime(int num) {
        for (int i = 2; i < Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    static List<Integer> getPrime(int start, int end) {
        List<Integer> results = new ArrayList<>();
        for (int i = start; i <= end; i++) {
            if (isPrime(i) && i != 1) {
                results.add(i);
            }
        }
        return results;
    }
}

  5. CachePool的使用

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

public class Demo6_CachePool {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        System.out.println(service);

        for (int i = 0; i < 2; i++) {
            service.execute(()->{
                try {
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);

        TimeUnit.SECONDS.sleep(60);
        System.out.println(service);

        TimeUnit.SECONDS.sleep(1);
        System.out.println(service);
    }
}

  6. SingleThreadPool的使用

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

public class Demo7_SingleThreadPool {

    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 5; i++) {
            final int j = i;
            service.execute(()->{
                System.out.println(j + " " + Thread.currentThread().getName());
            });
        }
    }
}

  7. SchedulePool的使用

    import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo8_SchedulePool {

    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        service.scheduleAtFixedRate(() -> {
            try {
                TimeUnit.MICROSECONDS.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }, 0, 500, TimeUnit.MILLISECONDS);
    }
}

  8. WorkStealingPool的使用

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

public class Demo9_WorkStealingPool {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newWorkStealingPool();
        System.out.println(Runtime.getRuntime().availableProcessors());

        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));

        TimeUnit.SECONDS.sleep(90);
    }

    static class R implements Runnable {

        int time;

        public R(int time) {
            this.time = time;
        }

        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time + " " + Thread.currentThread().getName());
        }
    }

}

  9. ForkJoinPool的使用

    import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

public class Demo10_ForkJoinPool {
    static int[] nums = new int[1000000];
    static final int MAX_NUM = 50000;
    static Random r = new Random();

    static {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = r.nextInt(100);
        }
        System.out.println(Arrays.stream(nums).sum());
    }

	/*static class AddTask extends RecursiveAction {

		int start, end;

		AddTask(int s, int e) {
			start = s;
			end = e;
		}

		@Override
		protected void compute() {
			if(end-start <= MAX_NUM) {
				long sum = 0L;
				for(int i=start; i<end; i++){
					sum += nums[i];
				}
				System.out.println(sum);
			} else {
				int middle = start + (end-start)/2;
				AddTask subTask1 = new AddTask(start, middle);
				AddTask subTask2 = new AddTask(middle, end);
				subTask1.fork();
				subTask2.fork();
			}
		}
	}*/

    static class AddTask extends RecursiveTask<Long> {

        int start, end;

        AddTask(int s, int e) {
            start = s;
            end = e;
        }

        @Override
        protected Long compute() {
            if (end - start <= MAX_NUM) {
                long sum = 0L;
                for (int i = start; i < end; i++) {
                    sum += nums[i];
                }
                return sum;
            }
            int middle = start + (end - start) / 2;
            AddTask subTask1 = new AddTask(start, middle);
            AddTask subTask2 = new AddTask(middle, end);
            subTask1.fork();
            subTask2.fork();
            return subTask1.join() + subTask2.join();
        }
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        AddTask task = new AddTask(0, nums.length);
        forkJoinPool.execute(task);
        long result = task.join();
        System.out.println(result);

        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
二狗家有矿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
23 高并发编程和线程池
08-07
23 高并发编程和线程池，教程视频：java中高并发编程和线程池
ExecutorService线程池
HD243608836的博客
10-16 608
ExecutorService的submit和execute ExecuteService代表的是Executors创建的线程池①submit提交的是实现了Callable接口的方法，有返回值（返回Future，执行future.get()方法即可获取具体返回值）②execute执行的是实现了Runnable接口的方法，没有返回值所以线程池对象executorService选择使用submit和...
ExecutorService的submit()方法
FantasticXX的博客
05-03 1万+
ExecutorService总共有三个submit方法： Future<?> submit(Runnable task); <T> Future<T> submit(Runnable task, T result); <T> Future<T> submit(Callable<T> task); 在AbstractEx...
Java并发基础(18)：ExecutorService中submit方法详解
mingyuli的博客
04-05 2898
1 submit() submit( )：该方法接收Runnable或Callable对象作为输入参数（该方法输入参数请参考上篇文章java线程池任务提交（Runnable、Callable、FutureTask）， 这篇文章主要讲submit方法的返回值以及返回值的使用），返回一个Future对象。submit方法提交的任务中的call方法如果返回Integer，那么submit方法就返回Future<Integer>；如果call方法返回Float，那么submit方法就返回Future&
Java线程池ExecutorService、日程线程池、CompletableFuture、延迟执行器的 execute()、submit()、runAsync() 等异步线程出现异常分析
hkl_Forever的博客
11-07 3714
4、ScheduledExecutorService 日程线程池中 schedule()、execute() 和 submit() 都不会输出异常信息、但会终止程序，需要用 try/catch 捕捉异常打印出来 e.printStackTrace() (抛出系统异常或业务异常即可。1、在都不捕捉异常的情况下，execute() 会输出异常信息并终止程序，submit() 不会输出异常信息、但会终止程序。1、线程池任务、异步线程任务中出现运行时异常，会打断当前线程运行并且看不见异常信息，但不会打断主线程。
多线程学习笔记3
weixin_59230567的博客
08-16 319
线程状态-虚拟机中线程6种状态（Thread.State内部类中有）：新建 就绪 阻塞 等待 计时 结束 自定义线程池ThreadPoolExecutor voatile关键字：强制线程去看共享数据的最新值 原子操作类AutomicInteger及常用方法 synchronized和CAS 悲观锁 与乐观锁 并发工具类
java并发编程_线程池的使用方法(详解)
08-30
java并发编程_线程池的使用方法 java并发编程中，线程池是一种非常重要的概念，它可以帮助我们更好地管理线程，提高程序的性能和可扩展性。下面我们将详细介绍java线程池的使用方法。 一、任务和执行策略之间的...
Java – 并发编程 – 线程池
01-21
我们创建的线程在运行结束后都会被虚拟机销毁，如果线程数量多的话，频繁的创建和销毁线程会大大浪费时间和效率，更重要的是浪费内存，线程池可以让线程运行后不立刻销毁，而是让线程重复使用，继续执行其他任务 ...
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....
并发容器和线程池，java并发编程3
最新发布
04-29
我们挑选出⼀些⽐较有代表性的并发容器 1 类，来感受⼀下JDK⾃带的并发集合带来的“快感”。 ConcurrentLinkedQueue是⼀个基于链接节点的⽆界线程安全队列，它采⽤先进先出的规则对节点 进⾏排序，当我们添加⼀个...
ExecutorService.submit()与Executor.execute() 两个方法的相同与不同之处
HelloWorld的专栏
08-30 8552
说一说ExecutorService.submit()与Executor.execute() 两个方法的相同与不同之处 相同之处： Both submit() and execute() methods are used to submit a task to Executor framework for asynchronous execution. submit和execute方法均可以想线...
线程执行 之 ExecutorService.submit()方法执行内部逻辑解析 ThreadPoolExecutor
xiaoliuliu2050的专栏
02-22 2232
futureTask 继承了Runable 接口，所以本身就是一个线程，内部实现了run方法，当主线程使用ExecutorService.submit ()方法提交任务或者使用 futureTask.start() 启动子线程的时候，开始执行futuretask的run 方法，run 方法内部 调用了 Callable 接口的call方法 ，然后这个线程慢慢执行的过程中， 主线程执行完其他操作，调...
ExecutorService中submit()和execute()的区别
guo951207的博客
04-03 1286
在使用java.util.concurrent下关于线程池一些类的时候，相信很多人和我一样，总是分不清submit()和execute()的区别，今天从源码方面分析总结一下。 　　通常，我们通过Executors这个工具类提供多种方法来创建适合不同场景的线程池，这里就不一一介绍了。 execute()方法源码如下： public interface Executor { voi...
java并发编程（ExecutorService中的submit方法）详解
热门推荐
qq_26963495的博客
01-09 5万+
submit( )：该方法接收Runnable或Callable对象作为输入参数（该方法输入参数请参考上篇文章java线程池任务提交（Runnable、Callable、FutureTask）， 这篇文章主要讲submit方法的返回值以及返回值的使用），返回一个Future对象。submit方法提交的任务中的call方法如果返回Integer，那么submit方法就返回Future；如果call
Executors 提交线程，获取结果
yingcly003的专栏
02-14 443
闲来无事，就把目前使用的几种线程方法，写一下。仅供参考 package com.pian.thread; import com.sun.org.apache.xpath.internal.functions.FuncTrue; import java.util.concurrent.*; /** * @Auther: Administrator * @Date: 2020/2/14 ...
Netty源码分析：ChannelFuture与Future底层解析
保暖透气大裤衩LeoLee的博客
10-29 1101
继承关系 io.netty.channel.ChannelFuture extendsio.netty.util.concurrent.Futureextendsjava.util.concurrent.Future
ExecutorService的execute和submit方法
八荒六合唯我独尊
07-16 2571
在开发过程中，遇到了一个比较奇怪的问题。描述如下:在使用ThreadPoolExecutor时，用到了自定义的线程，并对线程设置了异常捕获策略,如下: public AppThread(Runnable runnable, String name) { super(runnable, name + "-" + CREATED.incrementAndGet());
关于ExecutorService中的execute()和submit()方法的区别
yzj479622672的博客
08-23 1576
java多线程
8锁问题
weixin_43937178的博客
10-18 145
背景：对于一个资源类，涉及了两个方法，如下： static class phone{ public synchronized void sendMail(){ System.out.println("发邮件~"); } public synchronized void call(){ System.out.println("打电话~"); } } 使用两个线程操纵资源类： publ
Java并发编程：线程池深度解析与实战
"本课程详细介绍了并发编程中的关键概念，特别是线程池的使用和原理。从线程的创建和管理到线程安全的实现，再到高级并发工具如锁和原子变量，最后深入探讨线程池的核心机制和应用场景。课程涵盖了Java中线程的三种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值