Java Executor框架创建不同类型的线程池范例

最新推荐文章于 2023-12-28 13:19:32 发布
最新推荐文章于 2023-12-28 13:19:32 发布
阅读量311 收藏
点赞数
分类专栏： Java多线程 文章标签： Executors 线程池 线程池拒绝策略
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzizhi/article/details/84971475
版权

Executors对象下有哪些可供我们使用的方法：

范例1：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample1 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useSingleThreadExecutor() {
        
        System.out.println("=== SingleThreadExecutor ===");
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        singleThreadExecutor.execute(() -> System.out.println(Thread.currentThread().getName() + " time1 = "+ formatter.format(new Date())));
        singleThreadExecutor.execute(() -> System.out.println(Thread.currentThread().getName() + " time2 = "+ formatter.format(new Date())));
        singleThreadExecutor.shutdown();
        try {
            singleThreadExecutor.awaitTermination(4, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        useSingleThreadExecutor();
    }
}
run:
=== SingleThreadExecutor ===
pool-1-thread-1 time1 = 2019-10-24 23:11:14.307
pool-1-thread-1 time2 = 2019-10-24 23:11:14.307
BUILD SUCCESSFUL (total time: 0 seconds)

范例2：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample2 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useCachedThreadPool() {
        System.out.println("=== CachedThreadPool ===");
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        LinkedList<Future<UUID>> uuids = new LinkedList();
        for (int i = 0; i < 10; i++) {
            Future<UUID> submittedUUID = cachedThreadPool.submit(() -> {
                UUID randomUUID = UUID.randomUUID();
                System.out.println("UUID " + randomUUID + "  " + Thread.currentThread().getName()+ " time1 = "+ formatter.format(new Date()));
                return randomUUID;
            });
            uuids.add(submittedUUID);
        }
        cachedThreadPool.execute(() -> uuids.forEach((future) -> {
            try {
                System.err.println("Result " + future.get() + "  " + Thread.currentThread().getName()+ " time2 = "+ formatter.format(new Date()));
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }));
        cachedThreadPool.shutdown();
        try {
            cachedThreadPool.awaitTermination(4, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        useCachedThreadPool();
    }
}

范例3：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample3 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useFixedThreadPool() {
        System.out.println("=== FixedThreadPool ===");
        ExecutorService fixedPool = Executors.newFixedThreadPool(4);
        LinkedList<Future<UUID>> uuids = new LinkedList<Future<UUID>>();
        for (int i = 0; i < 20; i++) {
            Future<UUID> submitted = fixedPool.submit(() -> {
                UUID randomUUID = UUID.randomUUID();
                System.out.println("UUID " + randomUUID + "  " + Thread.currentThread().getName()+ " time1 = "+ formatter.format(new Date()));
                return randomUUID;
            });
            uuids.add(submitted);
        }
        fixedPool.execute(() -> uuids.forEach((future) -> {
            try {
               System.err.println("Result " + future.get() + "  " + Thread.currentThread().getName()+ " time2 = "+ formatter.format(new Date()));
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }));
        fixedPool.shutdown();
        try {
            fixedPool.awaitTermination(4, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        useFixedThreadPool();
    }
}

范例4：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample4 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useScheduledThreadPool() {
        System.out.println("=== ScheduledThreadPool ===");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName()+ " time1 = "+ formatter.format(new Date())), 0, 2, TimeUnit.SECONDS);
        scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName()+ " time2 = "+ formatter.format(new Date())), 0, 2, TimeUnit.SECONDS);
        scheduledThreadPool.scheduleWithFixedDelay(() -> System.err.println(Thread.currentThread().getName()+ " time3 = "+ formatter.format(new Date())), 0, 2, TimeUnit.SECONDS);

        try {
            scheduledThreadPool.awaitTermination(6, TimeUnit.SECONDS);
            scheduledThreadPool.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        useScheduledThreadPool();
    }
}

范例5：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample5 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useSingleTreadScheduledExecutor() {
        System.out.println("=== SingleThreadScheduledThreadPool ===");
        ScheduledExecutorService singleThreadScheduler = Executors.newSingleThreadScheduledExecutor();
        singleThreadScheduler.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName()+ " time1 = "+ formatter.format(new Date())), 0, 2, TimeUnit.SECONDS);
        singleThreadScheduler.scheduleWithFixedDelay(() -> System.out.println(Thread.currentThread().getName()+ " time2 = "+ formatter.format(new Date())), 0, 2,TimeUnit.SECONDS);

        try {
            singleThreadScheduler.awaitTermination(6, TimeUnit.SECONDS);
            singleThreadScheduler.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        useSingleTreadScheduledExecutor();
    }
}
run:
=== SingleThreadScheduledThreadPool ===
pool-1-thread-1 time1 = 2019-10-24 23:23:16.446
pool-1-thread-1 time2 = 2019-10-24 23:23:16.447
pool-1-thread-1 time1 = 2019-10-24 23:23:18.448
pool-1-thread-1 time2 = 2019-10-24 23:23:18.448
pool-1-thread-1 time1 = 2019-10-24 23:23:20.447
pool-1-thread-1 time2 = 2019-10-24 23:23:20.449
BUILD SUCCESSFUL (total time: 6 seconds)

范例6：

package com.contoso;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;
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;
import java.util.concurrent.TimeUnit;

public class ExecutorsExample6 {

    static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void useWorkStealingThreadPool() {
        System.out.println("=== WorkStealingThreadPool ===");
        ExecutorService workStealingPool = Executors.newWorkStealingPool();

        workStealingPool.execute(() -> System.out.println(Thread.currentThread().getName() + " time1 = " + formatter.format(new Date())));

        Callable<UUID> generatesUUID = UUID::randomUUID;
        LinkedList<Callable<UUID>> severalUUIDsTasks = new LinkedList();
        for (int i = 0; i < 20; i++) {
            severalUUIDsTasks.add(generatesUUID);
        }

        try {
            List<Future<UUID>> futureUUIDs = workStealingPool.invokeAll(severalUUIDsTasks);
            for (Future<UUID> future : futureUUIDs) {
                if (future.isDone()) {
                    UUID uuid = future.get();
                    System.err.println(uuid + "  " + Thread.currentThread().getName() + " time2 = " + formatter.format(new Date()));
                }
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            workStealingPool.awaitTermination(6, TimeUnit.SECONDS);
            workStealingPool.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        useWorkStealingThreadPool();
    }
}

范例7：如何自定义线程池和超负载时的自定义拒绝策略

package com.myth;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class RejectThreadPoolDemo {

    public static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + "  Thread Name:" + Thread.currentThread().getName());
            try {
                Thread.sleep(100); // 模拟任务执行需要花费100毫秒的时间，因此会导致大量的任务被直接丢弃
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
         // 自定义一个线程池，该线程池有5个常驻线程，并且最大线程数量也是5个，相当于一个固定大小的线程池，但只定义了10个容量的等待队列，
         // 因为使用无界队列可能并不是最佳的解决方案，如果任务量很极大，很有可能会把内存撑爆，所以定义一个合理的队列大小也是合乎常理的选择
         // 其中又自定义了拒绝策略，我们不抛出异常，因为万一在任务提交端没有进行异常处理，则有可能使得整个系统都崩溃，自定义拒绝策略记
         // 录被丢弃的任务，这样设计比内置的DiscardPolicy策略更灵活一点
        ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10),
        new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                // 实际应用中，我们可以将更详细的信息记录到日志中，来分析系统的负载和任务丢失的情况
                System.out.println(r.toString() + " is discard");
            }
        });
        for (int i = 0; i < 100; i++) {
            es.submit(task);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
run:
1572692317738  Thread Name:pool-1-thread-1
1572692317749  Thread Name:pool-1-thread-2
1572692317760  Thread Name:pool-1-thread-3
1572692317771  Thread Name:pool-1-thread-4
1572692317782  Thread Name:pool-1-thread-5
1572692317839  Thread Name:pool-1-thread-1
1572692317850  Thread Name:pool-1-thread-2
1572692317861  Thread Name:pool-1-thread-3
1572692317872  Thread Name:pool-1-thread-4
1572692317883  Thread Name:pool-1-thread-5
1572692317940  Thread Name:pool-1-thread-1
1572692317951  Thread Name:pool-1-thread-2
1572692317965  Thread Name:pool-1-thread-3
1572692317973  Thread Name:pool-1-thread-4
1572692317984  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@3d4eac69 is discard
java.util.concurrent.FutureTask@42a57993 is discard
java.util.concurrent.FutureTask@75b84c92 is discard
java.util.concurrent.FutureTask@6bc7c054 is discard
1572692318040  Thread Name:pool-1-thread-1
1572692318051  Thread Name:pool-1-thread-2
1572692318066  Thread Name:pool-1-thread-3
1572692318074  Thread Name:pool-1-thread-4
1572692318085  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@232204a1 is discard
java.util.concurrent.FutureTask@4aa298b7 is discard
java.util.concurrent.FutureTask@7d4991ad is discard
java.util.concurrent.FutureTask@28d93b30 is discard
1572692318140  Thread Name:pool-1-thread-1
1572692318151  Thread Name:pool-1-thread-2
1572692318166  Thread Name:pool-1-thread-3
1572692318174  Thread Name:pool-1-thread-4
1572692318185  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@1b6d3586 is discard
java.util.concurrent.FutureTask@4554617c is discard
java.util.concurrent.FutureTask@74a14482 is discard
java.util.concurrent.FutureTask@1540e19d is discard
1572692318241  Thread Name:pool-1-thread-1
1572692318252  Thread Name:pool-1-thread-2
java.util.concurrent.FutureTask@677327b6 is discard
1572692318267  Thread Name:pool-1-thread-3
1572692318275  Thread Name:pool-1-thread-4
1572692318286  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@14ae5a5 is discard
java.util.concurrent.FutureTask@7f31245a is discard
java.util.concurrent.FutureTask@6d6f6e28 is discard
java.util.concurrent.FutureTask@135fbaa4 is discard
1572692318342  Thread Name:pool-1-thread-1
1572692318353  Thread Name:pool-1-thread-2
1572692318368  Thread Name:pool-1-thread-3
1572692318376  Thread Name:pool-1-thread-4
1572692318387  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@45ee12a7 is discard
java.util.concurrent.FutureTask@330bedb4 is discard
java.util.concurrent.FutureTask@2503dbd3 is discard
java.util.concurrent.FutureTask@4b67cf4d is discard
1572692318443  Thread Name:pool-1-thread-1
1572692318454  Thread Name:pool-1-thread-2
1572692318469  Thread Name:pool-1-thread-3
1572692318477  Thread Name:pool-1-thread-4
1572692318488  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@7ea987ac is discard
java.util.concurrent.FutureTask@12a3a380 is discard
java.util.concurrent.FutureTask@29453f44 is discard
java.util.concurrent.FutureTask@5cad8086 is discard
1572692318544  Thread Name:pool-1-thread-1
1572692318555  Thread Name:pool-1-thread-2
1572692318570  Thread Name:pool-1-thread-3
1572692318578  Thread Name:pool-1-thread-4
1572692318589  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@6e0be858 is discard
java.util.concurrent.FutureTask@61bbe9ba is discard
java.util.concurrent.FutureTask@610455d6 is discard
java.util.concurrent.FutureTask@511d50c0 is discard
1572692318652  Thread Name:pool-1-thread-1
1572692318656  Thread Name:pool-1-thread-2
1572692318671  Thread Name:pool-1-thread-3
1572692318682  Thread Name:pool-1-thread-4
1572692318690  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@60e53b93 is discard
java.util.concurrent.FutureTask@5e2de80c is discard
java.util.concurrent.FutureTask@1d44bcfa is discard
java.util.concurrent.FutureTask@266474c2 is discard
java.util.concurrent.FutureTask@6f94fa3e is discard
1572692318753  Thread Name:pool-1-thread-1
1572692318757  Thread Name:pool-1-thread-2
1572692318772  Thread Name:pool-1-thread-3
1572692318783  Thread Name:pool-1-thread-4
1572692318791  Thread Name:pool-1-thread-5
java.util.concurrent.FutureTask@5e481248 is discard
1572692318853  Thread Name:pool-1-thread-1
1572692318858  Thread Name:pool-1-thread-2
1572692318872  Thread Name:pool-1-thread-3
1572692318883  Thread Name:pool-1-thread-4
1572692318891  Thread Name:pool-1-thread-5
1572692318954  Thread Name:pool-1-thread-1
1572692318959  Thread Name:pool-1-thread-2
1572692318973  Thread Name:pool-1-thread-3
1572692318984  Thread Name:pool-1-thread-4
1572692318992  Thread Name:pool-1-thread-5

范例8：

package com.myth;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

// 自定义扩展线程池，例如我们可以监控每个任务的开始和结束时间，在实际应用中，可以对其进行扩展来实现
// 对线程池运行状态的跟踪，输出一些有用的调试信息，以帮助对系统的故障诊断，这对于多线程程序排错很有帮助
public class CustomThreadPoolDemo {

    public static class MyTask implements Runnable {

        public String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println("正在执行" + " ThreadID =" + Thread.currentThread().getId() + " ,TaskName = " + name);
            try {
                Thread.sleep(100); // 模拟任务执行需要花费100毫秒的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()) {
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println("准备执行： " + ((MyTask) r).name);
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println("执行完成： " + ((MyTask) r).name);
            }

            @Override
            protected void terminated() {
                System.out.println("线程池退出");
            }
        };

        for (int i = 0; i < 5; i++) {
            MyTask task = new MyTask("Task" + i);
            es.execute(task);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        es.shutdown();
    }
}
run:
准备执行： Task0
正在执行 ThreadID =10 ,TaskName = Task0
准备执行： Task1
正在执行 ThreadID =11 ,TaskName = Task1
准备执行： Task2
正在执行 ThreadID =12 ,TaskName = Task2
准备执行： Task3
正在执行 ThreadID =13 ,TaskName = Task3
准备执行： Task4
正在执行 ThreadID =14 ,TaskName = Task4
执行完成： Task0
执行完成： Task1
执行完成： Task2
执行完成： Task3
执行完成： Task4
线程池退出
BUILD SUCCESSFUL (total time: 0 seconds)

 

zhengzizhi
关注
专栏目录
Java基础学习总结（108）——Java常见面试题再总结
科技D人生
07-11 1201
1.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？ Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。 2.JDK和JRE的区别是什
JAVA线程池相关参数和不同类型的线程池
melody_161106的博客
11-05 231
为什么要使用线程池 使用线程池的最大原因就是可以根据系统的需求和硬件环境灵活地控制线程数量，且可以对所有线程进行统一的管理和控制，从而提高系统的运行效率，降低系统的运行压力。 线程和任务分离，提高线程的重用性； 控制线程的并发数量，降低服务器压力，统一管理所有线程； 提高系统响应速度，假如创建线程的时间为T1,执行任务的时间为T2.销毁线程的时间T3，那么使用线程池就免去了T1和T3的时间。 线程池的使用场景 只要存在并发，我们就要使用线程池，但是要合理设置参数。JDK一共提供了4种线程池，分别为
java 线程组作用_java 线程组
weixin_27437725的博客
02-13 241
ThreadGroup其实比ExecutorService更好用java做抓取的时候免不了要用到多线程的了，因为要同时抓取多个网站或一条线程抓取一个网站的话实在太慢，而且有时一条线程抓取同一个网站的话也比较浪费CPU资源。要用到多线程的等方面，也就免不了对线程的控制或用到线程池。 我在做我们现在的那一个抓取框架的时候，就曾经用过java.util.concurrent.ExecutorServ...
java线程池创建有几种_Java中Executors类中几种创建各类型线程池的方法及实例
weixin_39612297的博客
02-27 108
Executors：提供了一系列静态工厂方法用于创建各种线程池。1.Executors.newCachedThreadPool创建可变线程池如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。核心线程池大小为0，最大为Integer.MAX_VALUE，线程空闲存活时间是60秒。示例代码：ExecutorService cachedThreadPool = Executors....
Executors.newsingleThreadExecutor()简单入门
hnh_blog的博客
07-17 1万+
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。 Runable类： public class RunThread implements Runnable { private int count = 0; @Override public void run() { boolean flag = true; whil..
Java创建线程池的方式
致力于不留技术债务cuizb.top
03-09 1847
文章目录一、创建线程池的方式一般有两种：二、通过Executors工厂创建1. Executors.newSingleThreadExecutor()2. Executors.newFixedThreadPool(n)3. Executors.newCachedThreadPool()4. Executors.newScheduledThreadPool(n)三、通过new ThreadPoolExecutor(coreThreadSize, max... ...) 一、创建线程池的方式一般有两种： 通.
java并发编程实战范例（由浅入深代码范例和详细说明）.docx
06-15
3. **ExecutorService 和 Executors**：Java 提供了 Executor 框架来管理和控制线程。ExecutorService 是一个接口，用于执行提交到它的工作任务。Executors 工厂类提供了一系列静态方法来创建不同类型的 ...
JUC线程框架深度解析 — 07、线程池
androidsj的专栏
05-17 1150
 一堆线程一起完成一件事情就是线程池。 【 线程池的核心组成 】【 线程池分类 】➢ java.util.concurrent.Executors类可以创建线程池➣ 创建无大小限制的线程池 : public static ExecutorService newCacheThreadPool();➢ 创建固定大小的线程池 : public static ExecutorService newFixe...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
Tars-Java客户端源码分析
zhaohuodian的博客
08-28 356
在分布式计算中，远程过程调用（Remote Procedure Call，缩写 RPC）允许运行于一台计算机的程序调用另一个地址空间计算机的程序，就像调用本地程序一样，无需额外地为这个交互作用涉及到的代理对象构建、网络协议等进行编程。一般RPC架构，有至少三种结构，分别为注册中心，服务提供者和服务消费者。如图1.1所示，注册中心提供注册服务和注册信息变更的通知服务，服务提供者运行在服务器来提供服务，服务消费者使用服务提供者的服务。...
深入探究 Java 中的 Executors.newSingleThreadExecutor() 方法
最新发布
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
12-28 1527
本文将详细介绍 Java 中的 Executors.newSingleThreadExecutor() 方法，探讨其用法、优势、应用场景以及潜在的性能问题。我们将从基础语法到最佳实践，全面解析这个在多线程编程中常用的线程池实现，旨在帮助读者更好地理解和使用该方法。
Executors.newSingleThreadExecutor() 的使用
我的博客
07-11 406
Executors.newSingleThreadExecutor() 的使用
Executors 创建单例线程newSingleThreadExecutor
weixin_34082177的博客
11-23 624
1、Executors 创建单例线程newSingleThreadExecutor 代码如下public class ExecutorsDemo { public static void main(String[] args) throws Exception, ExecutionException { ExecutorService singleThreadExecuto...
java线程池(三) Executors.newSingleThreadExecutor
xupeng874395012的博客
09-27 5750
Executors.newSingleThreadExecutor()这种的实现方式，看名字我们就应该知道是使用单线程重来支持的。那这个是如何实现的呢，接下来我们通过分析代码说明 请看这段代码片段 public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedEx
Android开发之线程池管理ThreadPoolExecutor和Executors.newSingleThreadExecutor()
xiayiye5的博客
09-02 2065
在Android开发中网络请求数据在Android4.0以后禁止在主线程请求，那么我们只有新开启线程请求数据了 一般都喜欢简单点这样写： new Thread(new Runnable() { @Override public void run() { } }).start(); ...
java JUC线程池：Executors.newSingleThreadExecutor代码示例
学亮编程手记
12-31 467
package com.zxl.juc; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 当任务队列来使用 * newSingleThreadExecutor可以让任务顺序执行 * 不用关注线程的生命周期，由线程池自己维护 * */ public class SingleThreadExecutorDemo1 { public static void mai
多线程----Executor框架之ThreadPoolExecutor三种实现方式
m0_47743175的博客
11-02 801
多线程----Executor框架之ThreadPoolExecutor三种实现方式，根据返回内容理解原理
JAVA多线程实现-单线程化线程池newSingleThreadExecutor
山禾园地
03-21 4万+
    JAVA通过Executors提供了四种线程池，单线程化线程池(newSingleThreadExecutor)、可控最大并发数线程池(newFixedThreadPool)、可回收缓存线程池(newCachedThreadPool)、支持定时与周期性任务的线程池(newScheduledThreadPool)。本篇文章主要介绍newSingleThreadExecutor，其他三种线程池...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值