多线程，高并发初步（5，线程池）

最新推荐文章于 2023-04-20 20:50:51 发布
最新推荐文章于 2023-04-20 20:50:51 发布
阅读量113 收藏
点赞数

基础知识
接口Executor：执行器
这是最初步的东西，只有一个execute方法。

/**
*Executor：执行器，只有一个execute方法。
 *
 * @author zhouyi
 *
*/
public class MyExecutor implements Executor {

public static void main(String[] args){
new MyExecutor().execute(()->System.out.println(“hello！zhouyi”));
}

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

接口ExecutorService
他是这样描述的：public abstract interface ExecutorService extends Executor，显然继承了Executor。里面封装了很多的方法。

public abstract interface ExecutorService extends Executor {
public abstract void shutdown();

public abstract List<Runnable> shutdownNow();

public abstract boolean isShutdown();-------是不是结束了

public abstract boolean isTerminated();

public abstract boolean awaitTermination(long paramLong,-------------等待结束
TimeUnit paramTimeUnit) throws InterruptedException;

public abstract <T> Future<T> submit(Callable<T> paramCallable);--------提交

public abstract <T> Future<T> submit(Runnable paramRunnable, T paramT);

public abstract Future<?> submit(Runnable paramRunnable);

public abstract <T> List<Future<T>> invokeAll( ------------------------调用所有
Collection<? extends Callable<T>> paramCollection)
throws InterruptedException;

public abstract <T> List<Future<T>> invokeAll(
Collection<? extends Callable<T>> paramCollection, long paramLong,
TimeUnit paramTimeUnit) throws InterruptedException;

public abstract <T> T invokeAny(
Collection<? extends Callable<T>> paramCollection)
throws InterruptedException, ExecutionException;

public abstract <T> T invokeAny(
Collection<? extends Callable<T>> paramCollection, long paramLong,
TimeUnit paramTimeUnit) throws InterruptedException,
ExecutionException, TimeoutException;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

Callable,
其中有个call()方法。Runnable是没有返回值的并且不会抛出checked异常。相反Callable是有返回值的，可以根据需要选择使用。

类Executors，是一个工具类
是这么定义的：public class Executors；这个类中有很多很多方法，不细去讲。

基础ThreadPool–线程池的概念
线程池：就是扔了一堆线程在里面，等待任务被扔进去。维护者两个队列，一个是放执行队列，一个是放执行完的队列
newFixedThreadPool–固定线程池

public class myThreadPool {

public static void main(String[] args) throws InterruptedException {
// 固定线程池 ，ExecutorService可以往里扔任务的，execute，submit
ExecutorService service = Executors.newFixedThreadPool(5); // 启5个线程池
for(int i = 0; i < 6; i++) { // 扔6个任务进去
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);

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

运行结果：显然第六个线程，不能执行进入等待。
在这里插入图片描述

Future （未来的-结果）的概念
是这么定义的：

public abstract interface Future<V> {
public abstract boolean cancel(boolean paramBoolean);

public abstract boolean isCancelled();

public abstract boolean isDone();

public abstract V get() throws InterruptedException, ExecutionException;

public abstract V get(long paramLong, TimeUnit paramTimeUnit)
throws InterruptedException, ExecutionException, TimeoutException;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

举例子：
// 将来要执行的任务。执行后返回值；执行未来的返回值，放入未来的结果中

public class TestFuture {
public static void main(String[] args) {
    ExecutorService executor = Executors.newCachedThreadPool();
    Task task = new Task();
    Future<Integer> result = executor.submit(task); // 将来要执行的任务。执行后返回值
    executor.shutdown();

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

System.out.println("主线程在执行任务");

try {
    System.out.println("task运行结果"+result.get());
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

System.out.println("所有任务执行完毕");

}
}
class Task implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println(“子线程在进行计算”);
Thread.sleep(3000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

执行结果：
在这里插入图片描述
newFixedThreadPool—线程池
并行–解决效率，以及解释线程池的概念。

public class MyparallelComputing {
public static void main(String[] args) throws InterruptedException,ExecutionException{
    long start = System.currentTimeMillis();
    // 只用一个主线程
    List<Integer> list = getPrime(1,200000);
    long end = System.currentTimeMillis();
    System.out.println(end - start);
    // 利用线程池去实现
    final int cpuCoreNum = 4;

ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);

MyTask task1 = new MyTask(1, 80000);
MyTask task2 = new MyTask(80001, 130000);
MyTask task3 = new MyTask(130001,170000);
MyTask task4 = new MyTask(170001, 200000);

Future&lt;List&lt;Integer&gt;&gt; future1 = service.submit(task1);
Future&lt;List&lt;Integer&gt;&gt; future2 = service.submit(task2);
Future&lt;List&lt;Integer&gt;&gt; future3 = service.submit(task3);
Future&lt;List&lt;Integer&gt;&gt; future4 = service.submit(task4);

start = System.currentTimeMillis();
future1.get(); // 阻塞
future2.get();
future3.get();
future4.get();
end = System.currentTimeMillis();
System.out.println(end - start);

}

static class MyTask implements Callable<List<Integer>> {

int startPos,endPos;

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

@Override
public List&lt;Integer&gt; call() throws Exception {
    List&lt;Integer&gt; list = getPrime(startPos, endPos);
    return list;
}

}

static boolean isPrime(int a) {
for(int i = 1; i < a/2; i++) {
if(a % i == 0) return false;
}
return true;
}

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

newCachedThreadPool–线程池
线程池中没有线程，来一个任务就启动一个任务，起到你的系统能够支撑的线程，大概几万个。
他有一个生存周期：默认60秒

public class MyCachePool {
 public static void main(String[] args) throws InterruptedException,ExecutionException{
    ExecutorService service = Executors.newCachedThreadPool();

System.out.println(service);

for(int i = 0; i &lt; 2; i++) {
    service.execute(()-&gt;{
        try {
            TimeUnit.MICROSECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}
System.out.println(service);

TimeUnit.SECONDS.sleep(60);

System.out.println(service);

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

运行结果：
在这里插入图片描述

newSingleThreadExecutor–线程池
线程池里面只有一个线程。作用：能保证线程执行的前后顺序。
实例：

public class MyCachePool {
public static void main(String[] args) throws InterruptedException,ExecutionException{
    ExecutorService service = Executors.newSingleThreadExecutor();

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

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行结果：
在这里插入图片描述

newScheduledThreadPool–线程池
该线程池用来执行定时任务。

public class MyNewScheduledThreadPool {
public static void main(String[] args) throws InterruptedException,ExecutionException{
    ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
    service.scheduleAtFixedRate(()->{ // 以固定的（频率）时间执行任务
        try {
            TimeUnit.MICROSECONDS.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }, 0, 500, TimeUnit.MICROSECONDS); // 从0（马上执行），之后每隔500毫秒执行一次。
}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

newWorkStealingPool–线程池（ 经营线程）
该线程池，假如3个线程，每个线程都有一个队列，现在加入2线程已经执行完了，他会自动的去拿1，3队列里的任务执行（偷过来执行）。

public class MynewWorkStealingPool {
public static void main(String[] args) throws IOException{
    ExecutorService service = Executors.newWorkStealingPool();
    // 判断cpu是几核的，得到结果4核
    System.out.println(Runtime.getRuntime().availableProcessors());

service.execute(new R(1000)); // daemon 经营线程
service.execute(new R(2000));
service.execute(new R(3000));
service.execute(new R(5000));
service.execute(new R(7000));

// 这句话不要是看不到结果的，原因是因为这个线程池的特殊
System.in.read();

}

static class R implements Runnable {
int time;

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

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

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

运行结果：
在这里插入图片描述
ForkJoinPool --线程池（1.7新加）
常用通过RecursiveAction（没有返回值）和RecursiveTask（有返回值不举例了）来实现
是通过fork进行分叉，jion进行合并。这个概念很重要。用于特别难的大任务，我来这个来切分成子任务，子任务也还可以继续分。
最后合并在一起。
实例：超过阈值就分成两段。

public class ForkJoinPool  {

static int[] news = new int[1000000];
static final int MAX_NUM = 50000;
static Random random = new Random();

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

static class addTask extends RecursiveAction { //通过RecursiveAction和RecursiveTask

int start,end;

addTask(int s,int e) {
    this.start = s;
    this.end = e;
}

@Override
protected void compute() {
    if (end - start &lt; MAX_NUM) {
        long sum = 0;
        for(int i = start;i &lt;end; i++) sum += news[i];
        System.out.println("start:" + start + "to" + "end:" +end + "=" +sum);
    } else {
        int middle = start + ( end - start)/2;

        addTask task1 = new addTask(start,middle);
        addTask task2 = new addTask(middle,end);
        task1.fork();
        task2.fork();
    }
}

}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

运行结果;
在这里插入图片描述

线程池背后的原理 --ThreadPoolExecutor
以上的6大线程池都是以ThreadPoolExecutor为根基的（ForkJoinPool 除外），可以用这个自定义自己想要的线程池的参数。

总结：
线程池的基础：Executor , ExecutorService(submit) , Callable 和 Runnable , ThreadPool , Future

6大线程池
newFixedThreadPool， CachedPool , newSingleThreadExecutor , newScheduledThreadPool, newWorkStealingPool , ForkJoinPool

        </div>
liumouren233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段05讲、采用多线程方式模拟银行排队叫号.mp4 │ 高并发编程第一阶段06讲、用Runnable接口将线程的逻辑执行单元从控制中抽取出来.mp4 │ 高并发编程第一阶段07讲、策略模式在Thread和Runnable...
Executors基于for循环进行多线程处理
杨宇
06-18 4858
Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runnable来表示任务，Executor的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。 1.重点介绍newFixedThreadP...
多线程，高并发初步 + 源码（五，线程池）
weixin_42603009的博客
04-09 2142
基础知识 接口Executor：执行器 这是最初步的东西，只有一个execute方法。 /** *Executor：执行器，只有一个execute方法。 * * @author zhouyi * */ public class MyExecutor implements Executor { public static void main(String[] args){ new M...
被迫学习Java线程池
2021_fc的博客
09-30 328
前言：今天写了一段让自己头大的代码，没有几十年精神病写不出来的那种。给大家瞅瞅 /** * 用于向开发库插入数据 * 300万条数据 */ public class ThreadSaveDB { public static void main(String[] args) { int size = 3000000; for (int i=0;i<size;i++){ ThreadPoolExecutor executor = n
JAVA多线程处理for循环
热门推荐
m0_60342559的博客
04-06 1万+
public static void main(String[] args) { long start = System.currentTimeMillis(); List list = new ArrayList(); for (int i = 0; i < 1000; i++) { list.add(i); } //定义线程数量为20，可根据服务器配置适当调整大小
for循环内线程池并发执行任务，等到子线程全部处理完任务，主线程在执行java的实现方式
cbb
04-03 5721
当计数器减为 0 时，所有子线程的任务都已经执行完毕，主线程可以执行后续代码。在主线程中，调用 CountDownLatch.await() 方法阻塞等待所有子线程的任务执行完毕，直到计数器减为 0 才继续执行后续代码。请注意，在使用自定义线程池时，需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。请注意，在实际应用中，您还需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。请注意，在使用以上方法时，仍然需要考虑线程安全、并发访问等问题，并在代码中正确处理异常。
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段05讲、采用多线程方式模拟银行排队叫号.mp4 │ 高并发编程第一阶段06讲、用Runnable接口将线程的逻辑执行单元从控制中抽取出来.mp4 │ 高并发编程第一阶段07讲、策略模式在Thread和Runnable...
多线程数据采集器源码
10-17
【标题】"多线程数据采集器源码"所涉及的知识点主要集中在C#编程语言...它涵盖了C#的线程管理、并发控制、可能的网络请求以及数据库操作等多个方面，对于学习和实践C#多线程编程以及数据采集技术具有很高的参考价值。
ExecutorService线程池处理for循环
【莉婶】的博客
02-11 3754
参考链接：https://blog.csdn.net/bufanrong/article/details/90295576 功能背景:为提高性能，需要异步执行一个list的数据。 多线程处理过程概述: 利用ExecutorService创建线程池，代码如下： int TOTAL_THREADS = 4;//线程数 //数据库中的1万条数据; List list =...
java for 循环使用线程池优化
h103997661的博客
11-01 9861
    List&lt;News&gt; getNewsRoundup(List&lt;String&gt; newsIds, Integer roundupSize) {         Vector&lt;News&gt; resultList = new Vector&lt;&gt;();         ExecutorService executorService = Executors...
记一次java for循环改造多线程的操作
最新发布
人生不怕起点低，就怕没追求
04-20 1218
今天在开发质量平台时需要获取某些数据，要请求公司某个工程的OpenAPI接口A。此接口为返回通用数据的接口，且接口本身的RT都在2～3秒之间。使用该接口，需要进行两次循环获取，然后对返回数据进行处理组装，才能得到我这边工程需要的数据。 在最开始的时候，我天真的写了两层循环，外层循环为一星期的每一天，内层循环为选取的几个版本号。结果发现整个请求过程（请求接口B和C获取版本相关数据->两层循环请求接口A->数据过滤筛选->数据组装排序）下来，响应时间来到了恐怖的2分钟（🤔要被领导骂死了）
Java 使用Executors创建线程池
laomei
03-16 467
1.newCachedThreadPool: 返回一个缓存线程池; 如果处理的任务超过线程池中的线程数，并且没有可用的线程时，线程池会创建一个新的线程给一个任务。它会回收旧的线程，为之后使用。ExecutorService service = Executors.newCachedThreadPool();2.newFixedThreadPool: 固定大小的线程池。线程池内线程的数目是固定的，如果
Java中ExecutorService线程池的使用(Runnable和Callable多线程实现)
BADAO_LIUMANG_QIZHI的博客
08-09 7457
线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。不利于扩展，比如如定时执行、定期执行、线程中断，所以很有必要了解下ExecutorService的使用。ExecutorService是Java提供的线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。...
Java多线程（六）：线程池详解
澄白易的博客
04-26 5667
目录 1. 什么是线程池 2. 为什么要使用线程池 3. 线程池创建 3.1固定数量的线程池（Executors.newFixedThreadPool） 3.1.1 创建固定数量的线程池 3.1.2线程池返回结果 3.1.3 submit() VS execut() 3.2.4 线程工厂 3.2带缓存的线程池（Executors.newCachedThreadPool） 3.3执行定时任务（Executors.newSingleThreadExecutor） 3.3.1 延迟...
Java_线程池_ExecutorService_newFixedThreadPool(固定线程个数)_execute(new Runnable())
zs_life的博客
04-02 2997
/* * 线程池：一堆线程装在某个容器里，等着来运行 * 一个线程池维护着很多线程，也维护着一个待执行任务队列，还维护着一个结束的任务队列 * * * ExecutorService：一个接口，可以往这里面扔任务，Java的线程池都实现了ExecutorService接口 ...
Android线程优化之线程池的详解
刘桂林的博客
05-27 707
本文授权发布公众号【刘桂林】，星球【Hi Android】 ThreadPoolExecutor还是有很多可讲的，但是我选择的还是着重讲解Android中的四个线程池，网上对ThreadPoolExecutor的例子太多了，也比较杂，大家可以去看看。 Android中的线程池的概念来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为ThreadPoolExecu...
java线程池深入讲解_深入java线程池的使用详解
weixin_34438539的博客
02-16 94
在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提于交和执行是同时进行的，如果你想对任务的执行进行调度或是控制 同时执行的线程数量就需要额外编写代码来完成。5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，并且可以建立一个类似数据库连接 池的线程池来执行任务。这个架构主要有三个接口和其相应的具体类组成。这三个接口是Executor,...
并发、线程简单理解
weixin_44396684的博客
06-29 417
并发、线程简单理解
"深入学习Java多线程与并发编程：保证程序在并发情况下的正确性与安全性
并发是指在同一时间点有多个任务在同时执行，而高并发则是指在同一时间点有大量的请求需要同时处理。在实际应用中，我们需要根据实际需求来选择并发和高并发的处理方式。 5. 知识技能：要成为一名优秀的并发编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值