JAVA 线程优化及线程池管理

最新推荐文章于 2023-10-26 14:03:48 发布
最新推荐文章于 2023-10-26 14:03:48 发布
阅读量557 收藏
点赞数
分类专栏： Java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiankeufo/article/details/77930228
版权

一：优化HandlerThread

我们在 activity中start了一个HandlerThread，那么这个线程会启动一个looper消息循环，当activity退出了，这个HandlerThread线程并没有终止，还是在那里做looper死循环，如果页面跳转频繁重复，这样的无用线程会越来越多，占用系统资源，最终导致进程crash掉。

所以当HandlerThread已经没有利用价值的时候，将它停止掉，只有这样才能开发出健壮的android程序。

首先知道如何停止一个已经启动了的HandlerThread呢？

先看 Looper.loop()的核心代码：

[java]  view plain  copy
  1. while (true) {  
  2.     Message msg = queue.next(); // might block  
  3.     if (msg != null) {  
  4.         if (msg.target == null) {  
  5.             // No target is a magic identifier for the quit message.  
  6.             return;  
  7.         }  
  8.   
  9.         long wallStart = 0;  
  10.         long threadStart = 0;  
  11.   
  12.         // This must be in a local variable, in case a UI event sets the logger  
  13.         Printer logging = me.mLogging;  
  14.         if (logging != null) {  
  15.             logging.println(">>>>> Dispatching to " + msg.target + " " +  
  16.                     msg.callback + ": " + msg.what);  
  17.             wallStart = SystemClock.currentTimeMicro();  
  18.             threadStart = SystemClock.currentThreadTimeMicro();  
  19.         }  
  20.   
  21.         msg.target.dispatchMessage(msg);  

看到里面是一个无限循环，退出循环的条件是：msg.target == null;

也就是说，如果我们向此looper的MessageQueue发送一个target为null的message，就可以停止这个线程的远行。


继续看Looper.Java的代码：

会发现有一个方法：

[java]  view plain  copy
  1. public void quit() {  
  2.     Message msg = Message.obtain();  
  3.     // NOTE: By enqueueing directly into the message queue, the  
  4.     // message is left with a null target.  This is how we know it is  
  5.     // a quit message.  
  6.     mQueue.enqueueMessage(msg, 0);  
  7. }  
这个方法正是向MessageQueue发送了一个target为null的message！

所以，停止HandlerThread的方法终于找到了，就是使用quit方法，具体调用形式如下：

mHandlerThread.getLooper().quit();



二：线程池管理：

在时写异步程序只执行一遍就不需要了，为了方便经常会写下面的代码

new Thread(new Runnable() {
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

这样new出来的匿名对象会存在一些问题

1.由于是匿名的，无法对它进行管理

2.如果需要多次执行这个操作就new多次，可能创建多个，占用系统资源

3.无法执行更多的操作

使用线程池的好处

1.可以重复利用存在的线程，减少系统的开销

2.利用线程池可以执行定时、并发数的控制

线程池的作用：

线程池作用就是限制系统中执行线程的数量。

原理：根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约       1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。


Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1. newCachedThreadPool 
/**
	 * 可以缓存线程池
	 */
	public static void Function1() {
		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 30; i++) {//30次
			final int index = i;
			try {
				Thread.sleep(100); // 休眠时间越短创建的线程数越多
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			executorService.execute(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("active count = " + Thread.activeCount()
							+ " index = " + index);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}

打印结果

active count = 2 index = 0

active count = 3 index = 1

active count = 4 index = 2

active count = 5 index = 3

active count = 6 index = 4

active count = 7 index = 5

active count = 8 index = 6

active count = 9 index = 7

active count = 10 index = 8

active count = 11 index = 9

active count = 11 index = 10

active count = 11 index = 11

active count = 11 index = 12

active count = 11 index = 13

active count = 11 index = 14

active count = 11 index = 15

active count = 11 index = 16

active count = 11 index = 17

active count = 11 index = 18

active count = 11 index = 19

active count = 11 index = 20

active count = 11 index = 21

active count = 11 index = 22

active count = 11 index = 23

active count = 11 index = 24

active count = 11 index = 25

active count = 11 index = 26

active count = 11 index = 27

active count = 11 index = 28

active count = 11 index = 29

active count = 10 index = 30

从打印消息来看开始线程数在增加，后来稳定，可以修改休眠时间，休眠时间越短创建的线程数就越多，因为前面的还没执行完，线程池中没有可以执行的就需要创建；如果把休眠时间加大，创建的线程数就会少

2.newFixedThreadPool  根据传入的参数创建线程数目

/**
	 * 定长线程池
	 */
	public static void Function2() {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 30; i++) {
			final int index = i;
			executorService.execute(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("index = " + index
								+ "  thread count = " + Thread.activeCount());
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}

3.newScheduledThreadPool

/**
	 * 定长线程池，可做延时
	 */
	public static void Function3() {
		ScheduledExecutorService executorService = Executors
				.newScheduledThreadPool(5);
		executorService.schedule(new Runnable() {

			@Override
			public void run() {
				System.out.println("delay 3 seconds" + "  thread count = "
						+ Thread.activeCount());
			}
		}, 3, TimeUnit.SECONDS);
	}

	/**
	 * 定期执行，可以用来做定时器
	 */
	public static void Function4() {
		ScheduledExecutorService executorService = Executors
				.newScheduledThreadPool(3);
		executorService.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				System.out
						.println("delay 1 seconds, and excute every 3 seconds"
								+ "  thread count = " + Thread.activeCount());
			}
		}, 1, 3, TimeUnit.SECONDS);
	}

打印结果

delay 1 seconds, and excute every 3 seconds  thread count = 2
delay 1 seconds, and excute every 3 seconds  thread count = 3
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4
delay 1 seconds, and excute every 3 seconds  thread count = 4

4.newSingleThreadExecutor这个最简单

/**
	 * 单例线程
	 */
	public static void Function5() {
		ExecutorService singleThreadExecutor = Executors
				.newSingleThreadExecutor();
		for (int i = 0; i < 5; i++) {
			final int index = i;
			singleThreadExecutor.execute(new Runnable() {

				@Override
				public void run() {
					try {
						System.out.println("index = " + index
								+ "  thread count = " + Thread.activeCount());
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}

打印结果：

index = 0  thread count = 2
index = 1  thread count = 2
index = 2  thread count = 2
index = 3  thread count = 2
index = 4  thread count = 2

只创建了一个线程


[java]  view plain  copy
  1. while (true) {  
  2.     Message msg = queue.next(); // might block  
  3.     if (msg != null) {  
  4.         if (msg.target == null) {  
  5.             // No target is a magic identifier for the quit message.  
  6.             return;  
  7.         }  
  8.   
  9.         long wallStart = 0;  
  10.         long threadStart = 0;  
  11.   
  12.         // This must be in a local variable, in case a UI event sets the logger  
  13.         Printer logging = me.mLogging;  
  14.         if (logging != null) {  
  15.             logging.println(">>>>> Dispatching to " + msg.target + " " +  
  16.                     msg.callback + ": " + msg.what);  
  17.             wallStart = SystemClock.currentTimeMicro();  
  18.             threadStart = SystemClock.currentThreadTimeMicro();  
  19.         }  
  20.   
  21.         msg.target.dispatchMessage(msg);  

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。




[java]  view plain  copy
  1. while (true) {  
  2.     Message msg = queue.next(); // might block  
  3.     if (msg != null) {  
  4.         if (msg.target == null) {  
  5.             // No target is a magic identifier for the quit message.  
  6.             return;  
  7.         }  
  8.   
  9.         long wallStart = 0;  
  10.         long threadStart = 0;  
  11.   
  12.         // This must be in a local variable, in case a UI event sets the logger  
  13.         Printer logging = me.mLogging;  
  14.         if (logging != null) {  
  15.             logging.println(">>>>> Dispatching to " + msg.target + " " +  
  16.                     msg.callback + ": " + msg.what);  
  17.             wallStart = SystemClock.currentTimeMicro();  
  18.             threadStart = SystemClock.currentThreadTimeMicro();  
  19.         }  
  20.   
  21.         msg.target.dispatchMessage(msg);  
程序邦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java并发编程：juc线程池
08-09
通过深入了解 Java 并发编程和 JUC 线程池，您可以更好地管理线程之间的协作和同步，充分发挥多核处理器的优势，确保程序稳定运行。 了解 Java 并发编程和 JUC 线程池是现代软件开发者的必备知识。通过掌握并发编程...
Java线程池CallBack超时实现方案
Htdlz的博客
07-14 736
在实际的开发中我们可能会遇到这样的问题: 需要并发的查询返回数据整合在一起,还需要设定超时,以免有一些东西查的实在太久,无法按时返回数据.我的思路是使用CountDownLatch实现. public abstract class AbstractCallBackThread<T> implements Runnable{ private Consumer<T> callBack; private CountDownLatch countDownLatch; .
java callback 多线程_JAVA Callback效率测试
weixin_42499363的博客
02-19 419
在最近的联网电商项目中，想要实现单个web容器内的支付请求，全部能够统一宏观上同步，实现粒度上面异步，找来找去，没有相关方面的框架或者方案，于是最后基于现实场景，打算使用Java callback 的多线程方式，假象伪并发量为100000/**** @author gyx**/public class A{private double id = 0;public A(double id){th...
解决new Thread().Start导致高并发CPU 100%的问题
dotNET跨平台
07-31 1103
背景之前接手一个项目的时候，发现到处是newThread(()=>{ //dosomething }).Start();这么做的目的，无非是为了减少页面等待时间提高用户体验，把一些浪费时间的操作放到新线程中在后台运行。问题但是这样带来的问题是大量的创建线程，非常影响项目的性能，尤其是在一些大并发量访问的时候，经常导致后果是cpu 100%。当然，如果你的项目到处...
如何优雅的管理线程池
vespera的博客
12-22 385
在开发中、我们经常会碰到一个工程中会用到多个线程池，在代码中、我们大多会在当前业务代码里直接创建线程池，如果有多个功能去创建多个线程池、在不同地方是不方便我们管理的、其他开发同事也并不会对每个业务很熟悉、在开发时便会有不必要的工时浪费。那么我们如何优雅的管理线程池呢？
java线程池调优小技巧
Ye_Xing_的博客
07-06 634
java线程调优小技巧
java多线程导出excel（千万级别）优化
12-05
轻松解决普通poi形式导出Excel的中出现的栈溢出问题，此资源可实现千万级数据分批导出csv文件，csv大数据量导出(千万级别，不会内存溢出)，多线程导出 ，生产环境已经很稳定的使用着
更好的使用Java线程池
12-22
这篇文章结合Doug Lea大神在JDK1.5提供的JCU包，分别从线程池大小参数的设置、工作线程的创建、空闲线程的回收、阻塞队列的使用、任务拒绝策略、线程池Hook等方面来了解线程池的使用，其中涉及到一些细节包括不同...
Java – 并发编程 – 线程池
01-21
线程池的优化 降低资源消耗 提高响应速度 提高线程的可管理性 流程图 线程池的核心参数 /** * 线程核心参数 * @param corePoolSize 核心线程数量 * @param maximumPoolSize 最大线程数量 * @param ...
使用java的HttpClient实现多线程并发
09-01
主要介绍了使用java的HttpClient实现多线程并发的相关资料,需要的朋友可以参考下
JAVA线程池如何调优
热门推荐
Venus's Blog
08-16 1万+
在JAVA中，线程可以使用定制的代码来管理，应用也可以利用线程池。在使用线程池时，有一个因素非常关键：调节线程池的大小对获得最好的性能至关重要。线程池的性能会随线程池大小这一基本选择而有所不同，在某些条件下，线程池过大对性能也有很多不利的影响。 所有线程池的工作方式本质是一样的：有一个任务队列，一定数量的线程会从该任务队列获取任务然后执行。任务的结果可以发回客户端，或保存到数据库，或保存到某个内部数据结构中，等等。但是在执行完任务后，这个线程会返回任务队列，检索另一个任务并执行。 线程池有最小线程数和最大线
java中的线程池管理
胡萝北的博客
08-09 726
文章目录线程池作用线程池的创建线程池的执行流程介绍线程池饱和策略分类创建线程池例子执行AbortPolicy策略执行DiscardPolicy策略执行DiscardOldestPolicy策略执行CallerRunsPolicy策略 线程池作用 顾名思义，管理线程的池子，相比于手工创建、运行线程，使用线程池，有如下优点 降低线程创建和销毁线程造成的开销 提高响应速度。任务到达时，相对于手工创建一个线程，直接从线程池中拿线程，速度肯定快很多 提高线程可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统
Java多线程秘籍，掌握这5种方法，让你的代码优化升级
最新发布
资料免费分享，点击名片
10-26 254
如果您需要更多的控制和灵活性，请查看 ThreadPoolExecutor，它是 Executors.newFixedThreadPool() 返回的 ExecutorService 的实际实现。通过限制特定任务使用的线程数，您可以根据优先级分配线程数：对于重要且频繁的任务使用更多线程，对于琐碎或偶尔的任务使用较少线程。虽然它在许多其他异步方法的底层使用中，但对于可以分解为较小且独立子任务的任务来说，它也非常强大，这些任务可以通过分而治之的策略来解决。请注意，b 预计计数的次数是其他实例的两倍。
Java线程池优化思路
weixin_43442127的博客
03-09 434
一般用数组型任务队列ArrayBlockingQueue和链表型队列LinkedBlockingQueue，ArrayBlockingQueue的读锁和写锁公用一把锁，而LinkedBlockingQueue的读锁和写锁是分开的，因此LinkedBlockingQueue效率更高。根据服务器配置调整核心线程数，最大线程数和阻塞队列的大小。当线程池的线程阻塞，会导致线程池效率变低，可以使用非阻塞IO，比如NIO和AIO等。抛弃队列最前面的任务，重新提交被拒绝的任务：适用于处理速率蛮，提交速率快的场景。
Java——线程池详细讲解
weixin_51351637的博客
05-04 3282
​线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。​ 这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象​ 核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定​ 例如:执行一个任务需要0.1秒,系统百分之80的时间每秒都会产生100个任务,那么要想在1秒内处理完这100个务,就需要10个线程,此时我们就可以设计核心线程数为10;
Java线程池
qq_40194724的博客
06-08 1429
指定的时间之后开始周期性的执行任务，执行周期间隔为第三个参数指定的时间，但是这两个方法的区别在于第三个方法执行任务的间隔是固定的，无论上一个任务是否执行完成，而第四个方法的执行时间间隔是不固定的，其会在周期任务的上一个任务执行完成之后才开始计时，并在指定时间间隔之后才开始执行任务。使用该策略时线程池饱和后将由调用线程池的主线程自己来执行任务，因此在执行任务的这段时间里主线程无法再提交新任务，从而使线程池中工作线程有时间将正在处理的任务处理完成。使用该队列时，如果任务数大于最大线程数，会抛出异常。
深入理解java常用的线程池，以及如何优雅的使用和管理线程
LYQ
10-04 1562
本文通过一个模拟网络下载功能，开启多任务下载操作，其中每条下载都开辟新线程的例子，来具体介绍线程池的常用几种方法。我们每次点击下载按钮，都会开启一个新的线程来执行下载流程，可以看下图也就是说，我们每个任务开辟的都是一个新的线程，假如我们下载任务量非常庞大时，那开辟的线程将不可控制，先不说性能问题，如果出现了线程安全问题或者是线程的调度，处理起来都是非常困难的。所以这种情况下，非常的有必要引入线程池来管理这些线程。
Java线程池及调优
HY1273383167的博客
04-08 1986
1. Java的线程池 ① 合理使用线程池的好处 Java的线程池是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池。 合理使用线程池能带来的好处： 降低资源消耗。 通过重复利用已经创建的线程降低线程创建的和销毁造成的消耗。例如，工作线程Woker会无线循环获取阻塞队列中的任务来执行。 提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。 线程是稀缺资源，Java的线程池可以对线程资源进行统一分配、调优和监控。 ② 线
JUC_线程池详解与线程池调优
我认不到你的博客
10-19 996
众所周知，我们在创建线程的时候，需要new一个Thread的对象，这样每次都创建一个对象，不仅会消耗不必要的资源，而且如果并发量特别高的话，线程就会创建得特别的多，会造成OOM（内存溢出）的问题 那么线程池可以解决这些问题，假设（我这里为了方便初学的同学，可以先这样理解着），我们创建一个有10个线程的线程池放在那，外部请求来了，会调用线程池内部的10个线程，每个线程执行完自己的任务，会跑回线程池待着，等待下一个任务的调用，省去了创建线程的时间，并且如果并发量高了的话，我们会禁止其他请求的访问，就不会一直重
java 优化线程_JAVA线程优化
05-27
Java中线程的优化主要包括以下几个方面： 1. 线程池的使用：线程池可以避免频繁创建和销毁线程的开销，提高了线程的利用率。...总之，Java线程的优化需要从多个方面入手，综合考虑各种因素，才能达到最佳的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序邦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值