Java并发编程核心方法与框架-Executors的使用

最新推荐文章于 2021-04-26 18:09:51 发布
最新推荐文章于 2021-04-26 18:09:51 发布
阅读量145 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/umgsai/p/5671645.html
版权
合理利用线程池能够带来三个好处
  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
  3. 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

官方建议使用Executors工厂类来创建线程池对象

使用newCachedThreadPool()方法创建无界线程池

使用Executors类的newCachedThreadPool()方法创建的是无界线程池，可以进行线程自动回收。所谓的“无界线程池”就是池中存放线程个数理论上是Integer.MAX_VALUE。

public class Run1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                try {
                    System.out.println("Runnable1 begin:" + System.currentTimeMillis());
                    Thread.sleep(1000);
                    System.out.println("A");
                    System.out.println("Runnable1 end:" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                try {
                    System.out.println("Runnable2 begin:" + System.currentTimeMillis());
                    Thread.sleep(1000);
                    System.out.println("A");
                    System.out.println("Runnable2 end:" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        });
    }
}

程序运行结果如下：

Runnable1 begin:1470228063076
Runnable2 begin:1470228063076
A
A
Runnable2 end:1470228064081
Runnable1 end:1470228064081
线程池的线程复用效果
public class MyRunnable implements Runnable {
    private String username;
    public MyRunnable(String username) {
        super();
        this.username = username;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " username=" + username + " begin:" + System.currentTimeMillis());
        System.out.println(Thread.currentThread().getName() + " username=" + username + " end:" + System.currentTimeMillis());
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyRunnable("" + i));
        }
        Thread.sleep(2000);
        System.out.println();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyRunnable("" + i));
        }
    }
}

程序运行结果如下：

pool-1-thread-1 username=0 begin:1470229448635
pool-1-thread-4 username=3 begin:1470229448635
pool-1-thread-3 username=2 begin:1470229448635
pool-1-thread-2 username=1 begin:1470229448635
pool-1-thread-3 username=2 end:1470229448635
pool-1-thread-4 username=3 end:1470229448635
pool-1-thread-5 username=4 begin:1470229448635
pool-1-thread-1 username=0 end:1470229448635
pool-1-thread-5 username=4 end:1470229448636
pool-1-thread-2 username=1 end:1470229448635

pool-1-thread-1 username=2 begin:1470229450637
pool-1-thread-3 username=4 begin:1470229450637
pool-1-thread-3 username=4 end:1470229450637
pool-1-thread-2 username=0 begin:1470229450637
pool-1-thread-2 username=0 end:1470229450638
pool-1-thread-5 username=1 begin:1470229450637
pool-1-thread-4 username=3 begin:1470229450637
pool-1-thread-4 username=3 end:1470229450638
pool-1-thread-5 username=1 end:1470229450638
pool-1-thread-1 username=2 end:1470229450637

由打印结果可见，第一次for循环中创建了5个线程对象分别是pool-1-thread-1到pool-1-thread-5，第二次for循环中没有创建新的线程对象，复用了第一次for循环中创建的线程对象。

使用newCachedThreadPool(ThreadFactory)定制线程工厂
public class MyThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("定制池中线程对象的名称" + Math.random());
        return thread;
    }
}

public class Run {
    public static void main(String[] args) {
        MyThreadFactory myThreadFactory = new MyThreadFactory();
        ExecutorService executorService = Executors.newCachedThreadPool(myThreadFactory);
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "运行：" + System.currentTimeMillis());
            }
        });
    }
}

程序运行结果如下：

定制池中线程对象的名称0.2671917944865071运行：1470230269473
使用newFixedThreadPool(int)方法创建有界线程池
public class MyRunnable implements Runnable {
    String username;
    public MyRunnable(String username) {
        super();
        this.username = username;
    }
    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " username=" + username + " begin:" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " username=" + username + " end:" + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            executorService.execute(new MyRunnable("" + i));
        }
        for (int i = 0; i < 3; i++) {
            executorService.execute(new MyRunnable("" + i));
        }
    }
}

程序运行结果如下：

pool-1-thread-1 username=0 begin:1470230865037
pool-1-thread-3 username=2 begin:1470230865037
pool-1-thread-2 username=1 begin:1470230865037
pool-1-thread-3 username=2 end:1470230867043
pool-1-thread-1 username=0 end:1470230867042
pool-1-thread-3 username=0 begin:1470230867043
pool-1-thread-1 username=1 begin:1470230867043
pool-1-thread-2 username=1 end:1470230867043
pool-1-thread-2 username=2 begin:1470230867043
pool-1-thread-3 username=0 end:1470230869047
pool-1-thread-1 username=1 end:1470230869047
pool-1-thread-2 username=2 end:1470230869047

此时线程池中最多有三个线程。

使用newFixedThreadPool(int, ThreadFactory)定制线程工厂
public class MyThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("定制池中线程对象的名称" + Math.random());
        return thread;
    }
}

public class Run {
    public static void main(String[] args) {
        MyThreadFactory threadFactory = new MyThreadFactory();
        ExecutorService executorService = Executors.newFixedThreadPool(2, threadFactory);
        Runnable runnable = new Runnable() {
            
            @Override
            public void run() {
                try {
                    System.out.println("begin 我在运行" + System.currentTimeMillis() + " " + Thread.currentThread().getName());
                    Thread.sleep(2000);
                    System.out.println("end 我在运行" + System.currentTimeMillis() + " " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
        };
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
    }
}

程序运行结果如下：

begin 我在运行1470231214770 定制池中线程对象的名称0.07643716796315236
begin 我在运行1470231214770 定制池中线程对象的名称0.5060032203497645
end 我在运行1470231216773 定制池中线程对象的名称0.5060032203497645
end 我在运行1470231216773 定制池中线程对象的名称0.07643716796315236
begin 我在运行1470231216773 定制池中线程对象的名称0.5060032203497645
end 我在运行1470231218774 定制池中线程对象的名称0.5060032203497645
使用newSingleThreadExecutor()方法创建单一线程池
public class MyRunnable implements Runnable {
    String username;
    public MyRunnable(String username) {
        super();
        this.username = username;
    }
    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " username=" + username + " begin:" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " username=" + username + " end:" + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 3; i++) {
            executorService.execute(new MyRunnable("" + i));
        }
    }
}

程序运行结果如下：

pool-1-thread-1 username=0 begin:1470231470978
pool-1-thread-1 username=0 end:1470231472978
pool-1-thread-1 username=1 begin:1470231472978
pool-1-thread-1 username=1 end:1470231474982
pool-1-thread-1 username=2 begin:1470231474982
pool-1-thread-1 username=2 end:1470231476984

此时线程池中只有一个线程。

newSingleThreadExecutor(ThreadFactory) 使用方法与前面的大体一致。

转载于:https://www.cnblogs.com/umgsai/p/5671645.html

G19931112
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Executors 使用实例
04-16
java Executors 使用实例 concurrent.ExecutorService
《java并发编程的核心方法和框架》
04-19
《java并发编程的核心方法和框架》这本书旨在深入探讨这一主题，帮助开发者掌握Java环境下的并发处理技巧。 1. **线程基础** - **线程创建**：Java提供了两种主要的线程创建方式，一是通过实现`Runnable`接口，二...
Executors的使用
weixin_30731287的博客
08-23 161
Executors的使用 一、自带的线程池的工厂方法 1、newFixedThreadPool JDK文档描述：创建一个固定的现成池，该线程重用固定数量的线程。如果所有线程都处于活动状态，并且有新的任务时，会在队列中进行等待，直到线程可用。如果现成在关闭之前发生故障而终止，在执行后续任务时，则新现成将取代它池中的线程将存在，直到明确显示。 构造函数 public static...
Executor 如何使用？
ConstXiong
01-03 1613
Executor 英文意思是执行者，可以看出它的作用是提交和执行任务接口，也可以理解为是线程池。 Executor 有一个子接口ExecutorService，ExecutorService 可以管理和终止任务的方法，可以追踪异步任务的进度的Executor。 Executors 是线程池的工厂类，提供静态工具方法。使用Executors 可以方便地创建各种类型的线程池。但是由于 Exe...
Executor使用
爱学习 爱生活
04-26 218
1.调用包为 import java.util.concurrent.Executors; 2.Executor和Executors的区别： Executor：是一个接口，执行提交的对象Runnable任务 void execute(Runnable command); Executors：是一个包装类，提供很多静态方法，不能被实例化（如下被私有private），像一个工具类，和Collections类似 private Executors() {} ...
JAVA并发编程艺术pdf版
08-08
《JAVA并发编程艺术》是Java开发者深入理解和掌握并发编程的一本重要著作，它涵盖了Java并发领域的核心概念和技术。这本书详细阐述了如何在多线程环境下有效地编写高效、可靠的代码，对于提升Java程序员的技能水平...
Java—并发编程—-线程创建方式
12-20
Java并发编程中的线程创建是实现多任务并行执行的关键，尤其在现代计算机系统中，多核处理器的存在使得并发执行成为提升性能的有效手段。在Java中，有多种方式来创建和管理线程。 首先，我们可以选择继承`Thread`类...
Java编程之高并发核心源码
最新发布
11-17
首先，我们要了解Java并发编程的基础，即线程。Java提供了Thread类和Runnable接口来创建和管理线程。通过实现Runnable接口或继承Thread类，可以定义线程执行的逻辑。然而，线程的直接创建和管理可能会导致资源浪费，...
java并发编程艺术源码-ArtConcurrentBook:JAVA并发编程的艺术
05-25
《Java并发编程艺术》是一本深入探讨Java多线程与并发编程的经典著作，它涵盖了Java并发编程的基础到高级主题，旨在帮助开发者掌握在Java平台上进行高效并发编程的技术和最佳实践。源码ArtConcurrentBook提供了书中...
JAVA并发编程核心方法与框架-高洪岩著
11-03
JAVA并发编程核心方法与框架-高洪岩著 java 多并发经典书籍
《Java并发编程（核心方法与框架）》笔记记录
HY—Chan
10-06 847
此文记录学习《Java并发编程（核心方法与框架）》时的记录 代码见github：https://github.com/Bosssheep/JavaConcurrent 一、Semaphore Semaphore，这个单词翻译过来指：信号 在Java中此类主要用来限制线程并发的数量。 其常用方法如下： 方法 作用 Semaphore(int permits) 构造方法，permits...
JAVA中的Executors框架
madman
01-19 375
//单线程池 Executors.newSingleThreadExecutor(); //固定线程池 Executors.newFixedThreadPool(1); //创建一个无限大的线程，最大线程数不限制,一般用于定时任务。 Executors.newScheduledThreadPool(1); //队列策略为SynchronousQueue()的一种线程池。 Executors.new...
线程池中Executors应用(一)
daibalusu
04-26 100
Executors是JDK1.5中线程并发库的类（api参考java.util.concurrent），该类提供了 很多用于创建线程池的方法，返回的线程池都实现了ExecutorService接口，这些线程池通常可提高程序性能。 本章用到的方法： 1.创建指定线程大小 public static ExecutorService newFixedThreadPool(int nThrea...
Executors的部分方法使用一
hnlgzb的专栏
09-15 580
下面的代码是张孝祥老师的部分代码      
Java并发编程核心方法与框架-集合框架结构简要
G19931112的博客
07-14 124
待续 转载于:https://www.cnblogs.com/umgsai/p/5671678.html
Executors使用
wenjiehk的博客
11-14 1272
最近学习了BlockingQueue，在学习过程中看到了Executors的使用，以前没有专门的去了解和查看源码，现在去学习一下 Java通过Executors提供四种线程池，分别为： newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务...
JAVA多线程—Executors类的应用
此博客已停用，博文会逐渐转移到新地址，http://blog.csdn.net/liupeifeng3514
04-21 311
固定大小的线程池、缓存线程池、单一线程池代码示例：import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;public class ThreadPoolTest { public static void main(String[] args) { ExecutorSer
JAVA中的Executors使用
小桥流水-XY
05-12 1027
java 的Executors，Android的lruCache使用
Java并发编程深度解析：核心概念与实战应用
4. **线程和线程协作**：除了基本的线程控制，还包括了如何协调线程之间的交互，例如使用wait()、notify()和notifyAll()方法进行线程间的通信，以及守护线程（daemon threads）和线程池（Executors框架）的应用，后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值