怎样进行Java线程池管理及分布式Hadoop调度框架搭建

怎样进行Java线程池管理及分布式Hadoop调度框架搭建 ，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

Java线程池管理及分布式Hadoop调度框架搭建。
平时的开发中线程是个少不了的东西，比如tomcat里的servlet就是线程，没有线程我们如何提供多用户访问呢？不过很多刚开始接触线程的开发工程师却在这个上面吃了不少苦头。怎么做一套简便的线程开发模式框架让大家从单线程开发快速转入多线程开发，这确实是个比较难搞的工程。
那具体什么是线程呢？首先看看进程是什么，进程就是系统中执行的一个程序，这个程序可以使用内存、处理器、文件系统等相关资源。例如QQ软件、Eclipse、Tomcat等就是一个exe程序，运行启动起来就是一个进程。为什么需要多线程？如果每个进程都是单独处理一件事情不能多个任务同时处理，比如我们打开qq只能和一个人聊天，我们用eclipse开发代码的时候不能编译代码，我们请求tomcat服务时只能服务一个用户请求，那我想我们还在原始社会。多线程的目的就是让一个进程能够同时处理多件事情或者请求。比如现在我们使用的QQ软件可以同时和多个人聊天，我们用eclipse开发代码时还可以编译代码，tomcat可以同时服务多个用户请求。
线程这么多好处，怎么把单进程程序变成多线程程序呢？不同的语言有不同的实现，这里说下java语言的实现多线程的两种方式：扩展java.lang.Thread类、实现java.lang.Runnable接口。
先看个例子，假设有100个数据需要分发并且计算。看下单线程的处理速度：

1.     package thread;  
   

2.       
   

3.     import java.util.Vector;  
   

4.       
   

5.     public class OneMain {  
   

6.            public static void main(String[] args) throws InterruptedException {  
   

7.                 Vector<Integer> list = new Vector<Integer>(100);  
   

8.       
   

9.                  for (int i = 0; i < 100; i++) {  
   

10.                       list.add(i);  
    

11.                 }  
    

12.       
    

13.                  long start = System.currentTimeMillis();  
    

14.                  while (list.size() > 0) {  
    

15.                        int val = list.remove(0);  
    

16.                       Thread. sleep(100);//模拟处理  
    

17.                       System. out.println(val);  
    

18.                 }  
    

19.                  long end = System.currentTimeMillis();  
    

20.       
    

21.                 System. out.println("消耗 " + (end - start) + " ms");  
    

22.       
    

23.           }  
    

24.       
    

25.            // 消耗 10063 ms  
    

26.     }  
    

27. 
    

28. 再看一下多线程的处理速度，采用了10个线程分别处理：
    

29. 
    

30. [java] view plaincopy在CODE上查看代码片派生到我的代码片
    

31. 
    

32.     package thread;  
    

33.       
    

34.     import java.util.Vector;  
    

35.     import java.util.concurrent.CountDownLatch;  
    

36.       
    

37.     public class MultiThread extends Thread {  
    

38.          static Vector<Integer> list = new Vector<Integer>(100);  
    

39.          static CountDownLatch count = new CountDownLatch(10);  
    

40.       
    

41.          public void run() {  
    

42.       
    

43.               while (list.size() > 0) {  
    

44.                    try {  
    

45.                         int val = list.remove(0);  
    

46.                         System.out.println(val);  
    

47.                         Thread.sleep(100);//模拟处理  
    

48.                    } catch (Exception e) {  
    

49.                         // 可能数组越界，这个地方只是为了说明问题，忽略错误  
    

50.                    }  
    

51.       
    

52.               }  
    

53.                
    

54.               count.countDown(); // 删除成功减一  
    

55.       
    

56.          }  
    

57.       
    

58.          public static void main(String[] args) throws InterruptedException {  
    

59.                
    

60.               for (int i = 0; i < 100; i++) {  
    

61.                    list.add(i);  
    

62.               }  
    

63.                
    

64.               long start = System.currentTimeMillis();  
    

65.       
    

66.               for (int i = 0; i < 10; i++) {  
    

67.                    new MultiThread().start();  
    

68.               }  
    

69.       
    

70.                
    

71.       
    

72.               count.await();  
    

73.               long end = System.currentTimeMillis();  
    

74.               System.out.println("消耗 " + (end - start) + " ms");  
    

75.       
    

76.          }  
    

77.       
    

78.          // 消耗 1001 ms  
    

79.     }  

复制代码

大家看到了线程的好处了吧！单线程需要10S，10个线程只需要1S。充分利用了系统资源实现并行计算。也许这里会产生一个误解，是不是增加的线程个数越多效率越高。线程越多处理性能越高这个是错误的，范式都要合适，过了就不好了。需要普及一下计算机硬件的一些知识。我们的cpu是个运算器，线程执行就需要这个运算器来运行。不过这个资源只有一个，大家就会争抢。一般通过以下几种算法实现争抢cpu的调度：

• 队列方式，先来先服务。不管是什么任务来了都要按照队列排队先来后到。

• 时间片轮转，这也是最古老的cpu调度算法。设定一个时间片，每个任务使用cpu的时间不能超过这个时间。如果超过了这个时间就把任务暂停保存状态，放到队列尾部继续等待执行。

• 优先级方式：给任务设定优先级，有优先级的先执行，没有优先级的就等待执行。
  

这三种算法都有优缺点，实际操作系统是结合多种算法，保证优先级的能够先处理，但是也不能一直处理优先级的任务。硬件方面为了提高效率也有多核cpu、多线程cpu等解决方案。目前看得出来线程增多了会带来cpu调度的负载增加，cpu需要调度大量的线程，包括创建线程、销毁线程、线程是否需要换出cpu、是否需要分配到cpu。这些都是需要消耗系统资源的，由此，我们需要一个机制来统一管理这一堆线程资源。线程池的理念提出解决了频繁创建、销毁线程的代价。线程池指预先创建好一定大小的线程等待随时服务用户的任务处理，不必等到用户需要的时候再去创建。特别是在java开发中，尽量减少垃圾回收机制的消耗就要减少对象的频繁创建和销毁。
之前我们都是自己实现的线程池，不过随之jdk1.5的推出，jdk自带了java.util.concurrent并发开发框架，解决了我们大部分线程池框架的重复工作。可以使用Executors来建立线程池，列出以下大概的，后面再介绍。

• newCachedThreadPool建立具有缓存功能线程池

• newFixedThreadPool建立固定数量的线程

• newScheduledThreadPool建立具有时间调度的线程
  

有了线程池后有以下几个问题需要考虑：

• 线程怎么管理，比如新建任务线程。

• 线程如何停止、启动。

• 线程除了scheduled模式的间隔时间定时外能否实现精确时间启动。比如晚上1点启动。

• 线程如何监控，如果线程执行过程中死掉了，异常终止我们怎么知道。
  

考虑到这几点，我们需要把线程集中管理起来，用java.util.concurrent是做不到的。需要做以下几点：

• 将线程和业务分离，业务的配置单独做成一个表。

• 构建基于concurrent的线程调度框架，包括可以管理线程的状态、停止线程的接口、线程存活心跳机制、线程异常日志记录模块。

• 构建灵活的timer组件，添加quartz定时组件实现精准定时系统。

• 和业务配置信息结合构建线程池任务调度系统。可以通过配置管理、添加线程任务、监控、定时、管理等操作。
  

组件图为：



构建好线程调度框架是不是就可以应对大量计算的需求了呢?答案是否定的。因为一个机器的资源是有限的，上面也提到了cpu是时间周期的，任务一多了也会排队，就算增加cpu，一个机器能承载的cpu也是有限的。所以需要把整个线程池框架做成分布式的任务调度框架才能应对横向扩展，比如一个机器上的资源达到瓶颈了，马上增加一台机器部署调度框架和业务就可以增加计算能力了。好了，如何搭建？如下图：

基本前面的分布式调度框架组件不变，增加如下组件和功能：

• 改造分布式调度框架，可以把本身线程任务变成mapreduce任务并提交到hadoop集群。

• hadoop集群能够调用业务接口的spring、ibatis处理业务逻辑访问数据库。

• hadoop需要的数据能够通过hive查询。

• hadoop可以访问hdfs/hbase读写操作。

• 业务数据要及时加入hive仓库。

• hive处理离线型数据、hbase处理经常更新的数据、hdfs是hive和hbase的底层结构也可以存放常规文件。
  

这样，整个改造基本完成。不过需要注意的是架构设计一定要减少开发程序的复杂度。这里虽然引入了hadoop模型，但是框架上开发者还是隐藏的。业务处理类既可以在单机模式下运行也可以在hadoop上运行，并且可以调用spring、ibatis。减少了开发的学习成本，在实战中慢慢体会就学会了一项新技能。

关于怎样进行Java线程池管理及分布式Hadoop调度框架搭建 问题的解答就分享到这里了，希望以上内容可以对大家有一定的帮助，如果你还有很多疑惑没有解开，可以关注亿速云行业资讯频道了解更多相关知识。