jetty的线程池-QueuedThreadPool
jetty的线程池-QueuedThreadPool
一直对线程池有些疑问：
1.线程池怎么保证线程一直存在？
2.线程池怎么控制最大空闲时间？
3.线程池怎么回收线程？
。。。。
带着这些问题，看了一边jetty的线程池。
jetty有三个线程池，分别是ExecutorThreadPool，OldQueuedThreadPool，QueuedThreadPool
它们都实现了org.eclipse.jetty.util.thread.ThreadPool接口，并继承https://www.wendangku.net/doc/2014072914.html,ponent.AbstractLifeCycle
这里我们只关注QueuedThreadPool。
看名字就知道，它是跟队列相关的，没错。
QueuedThreadPool的存放jbos的集合(BlockingQueue
和存放线程的集合都是用队列实现的(ConcurrentLinkedQueue
看看QueuedThreadPool前面定义的private属性：
Java代码
1.public class QueuedThreadPool extends AbstractLifeCycle impleme
nts ThreadPool, Executor {
2. //已经启动的线程数
3. private final AtomicInteger _threadsStarted
= new AtomicInteger();
4. //空闲线程数
5. private final AtomicInteger _threadsIdle
= new AtomicInteger();
6.//上一次执行销毁线程的时间。这个就是用来控制最大空闲时间的
7. private final AtomicLong _lastShrink
= new AtomicLong();
8.//存放线程的集合
9. private final ConcurrentLinkedQueue
= new ConcurrentLinkedQueue
10.//一个锁
11. private final Object _joinLock
= new Object();
12.//存放任务的集合
13. private BlockingQueue
14.//以上这些都是线程安全的
15.
16.//下面这些都是参数，不会变的，所以无需线程安全控制
17. private String _name;
18. private int _maxIdleTimeMs
= 60000;
19. private int _maxThreads
= 254;
20. private int _minThreads
= 8;
21. private int _maxQueued
= -1;
22. private int _priority
= Thread.NORM_PRIORITY;
23. private boolean _daemon
= false;
24. private int _maxStopTime
= 100;
jetty里面的核心类都实现了lifecycle接口，所以该线程池初始化的时候，是调用的doStart()方法。
Java代码
1.protected void doStart() throws Exception {
2. super.doStart();
3. _threadsStarted.set(0);
4.
5. if (_jobs == null) {
6. _jobs = _maxQueued > 0 ? new ArrayBlockingQueue ble>(_maxQueued) : new BlockingArrayQueue _minThreads , 8. _minThreads ); 9. } 10. 11. int threads = _threadsStarted.get(); 12. // 启动一定数量的线程 13. while (isRunning() && threads < _minThreads) { 14. //启动线程 15. startThread(threads); 16. threads = _threadsStarted.get(); 17. } 18. } 首先初始化了父类，接着设置已经启动的线程数=0，设置存放jbos的集合。然后就开始启动线程了。直到已经启动的线程数=最小线程数。 至此，完成初始化。 再来看看startThread方法： Java代码 1................ 2. Thread thread = newThread(_runnable); 3. thread.setDaemon(_daemon); 4. thread.setPriority(_priority); 5. thread.setName(_name + "-" + thread.getId()); 6. _threads.add(thread); 7. thread.start(); 8. .............. 仅仅是启动了一个_runnable对象。其他的都没啥好看的。 赶紧看看这个_runnable是咋样的。 _runnable是一个runnable的匿名类，它的run方法里是一个while循环Java代码 1.while (isRunning()) { 2. 1.loop jobs 3. 2.阻塞或者回收线程 1.循环的从任务队列里面取任务，直到任务队列为空 Java代码 1.// 首先把jobs里面的任务都执行掉 2./ 首先把jobs里面的任务都执行掉 3. while (job != null && isRunning()) { 4. job.run(); 5. // jbos.poll()不阻塞，如果木有，直接返回null 6. job = _jobs.poll(); 7. } 2.接着，阻塞线程，回收线程 Java代码 1.// 没有可执行的任务，空闲线程数量+1 2. _threadsIdle.incrementAndGet(); 3. // 木有任务的情况下,使劲循环 4. while (isRunning() && job == null) { 5. // jbos.take()会阻塞，直到有一个job返回，这样就维持 了线程一直存在着 6. // 最大空闲时间<=0，则不回收线程，直接阻塞线程，等待任务 7. if (_maxIdleTimeMs <= 0) job = _jobs.take(); 8. else { 9. // maybe we should shrink? 10. // 已经启动的线程数 11. final int size = _threadsStarted.get(); 12. // 已经启动的线程数>_minThreads,判断是否需要回收 13. if (size > _minThreads) { 14. // 上一次回收线程的时间 15. long last = _lastShrink.get(); 16. // now 17. long now = System.currentTimeMillis(); 18. // 两次回收之间的时间间隔>最大空闲时间 19. if (last == 0 || (now - last) > _maxIdleTimeMs) { 20. // 回收掉 21. shrink = _https://www.wendangku.net/doc/2014072914.html,pareAndSet(last, now) 22. && _https://www.wendangku.net/doc/2014072914.html,pareAndSet(size, 23. size - 1); 24. if (shrink) return; 25. } 26. } 27. // 阻塞最大空闲时间，然后返回。 28. // 这次返回以后，如果让然没有任务可执行，并且启动的线程 数>_minThreads，则会回收掉 29. job = _jobs.poll(_maxIdleTimeMs, https://www.wendangku.net/doc/2014072914.html,LIS ECONDS); 30. } 31. } KETTLE 开源ETL软件】【安装配置与使用说明】 2015 年09 月 修订记录 目录 修订记录 (2) 1.安装与配置 (4) 1.1ETL 与K ETTLE概述 (4) 1.2K ETTLE的下载与安装 (7) 1.2.1Windows下安装配置 ............................................ Kettle 8 1.2.2Linux 下安装配置.................................................. Kettle 10 1.2.3Kettle 下安装..................................................... JDBC数据库驱动15 1.2.4下配置资源库连接 (15) 1.2.5Kettle 下 Hadoop Plugin 插件配置 (17) 2.KETTLE组件介绍与使用 (19) 2.1K ETTLE SPOON使用 (19) 2.1.1组件树介绍 (20) 2.1.2使用示例.......................................................... 1 23 2.1.3使用示例.......................................................... 2 37 2.1.4使用Kettle 装载数据到..................................... HDFS 48 2.1.5使用Kettle 装载数据到 (iv) 52 2.1.6使用 Kettle 进行 hadoop的 mapreduce图形化开发 (52) 2.2K ETTLE PAN的使用 (63) 2.3K ETTLE KITECHEN的使用 (64) 2.4C ARTE添加新的ETL执行引擎 (65) 2.5E NCR加密工具 (68) 一.Jetty 的基本架构 Jetty 目前的是一个比较被看好的 Servlet 引擎，它的架构比较简单，也是一个可扩展性和非常灵活的应用服务器，它有一个基本数据模型，这个数据模型就是 Handler，所有可以被扩展的组件都可以作为一个 Handler，添加到 Server 中，Jetty 就是帮你管理这些Handler。 整个 Jetty 的核心组件由 Server 和 Connector 两个组件构成，整个 Server 组件是基于Handler 容器工作的，它类似与 Tomcat 的 Container 容器，Jetty 与 Tomcat 的比较在后面详细介绍。Jetty 中另外一个比不可少的组件是 Connector，它负责接受客户端的连接请求，并将请求分配给一个处理队列去执行。 它的所有组件都是基于 Handler 来实现 Jetty 中还有一些可有可无的组件，我们可以在它上做扩展。如 JMX，我们可以定义一些Mbean 把它加到 Server 中，当 Server 启动的时候，这些 Bean 就会一起工作。 Jetty 可以基于 AJP 协议工作，在正常的企业级应用中，Jetty 作为一个 Servlet 引擎都是基于 AJP 协议工作的，所以它前面必然有一个服务器，通常情况下与 Jboss 集成的可能性非常大 Tomcat 和 Jetty 都是作为一个 Servlet 引擎应用的比较广泛，可以将它们比作为中国与美国的关系，虽然 Jetty 正常成长为一个优秀的 Servlet 引擎，但是目前的 Tomcat 的地位仍然难以撼动。相比较来看，它们都有各自的优点与缺点。 Tomcat 经过长时间的发展，它已经广泛的被市场接受和认可，相对 Jetty 来说 Tomcat 还是比较稳定和成熟，尤其在企业级应用方面，Tomcat 仍然是第一选择。但是随着 Jetty 的发展，Jetty 的市场份额也在不断提高，至于原因就要归功与 Jetty 的很多优点了，而这些优点也是因为 Jetty 在技术上的优势体现出来的。 架构比较 从架构上来说，显然 Jetty 比 Tomcat 更加简单 在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 线程池工作原理： 线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。 线程池的替代方案 线程池远不是服务器应用程序内使用多线程的唯一方法。如同上面所提到的，有时，为每个新任务生成一个新线程是十分明智的。然而，如果任务创建过于频繁而任务的平均处理时间过短，那么为每个任务生成一个新线程将会导致性能问题。 另一个常见的线程模型是为某一类型的任务分配一个后台线程与任务队列。AWT 和 Swing 就使用这个模型，在这个模型中有一个 GUI 事件线程，导致用户界面发生变化的所有工作都必须在该线程中执行。然而，由于只有一个 AWT 线程，因此要在 AWT 线程中执行任务可能要花费相当长时间才能完成，这是不可取的。因此，Swing 应用程序经常需要额外的工作线程，用于运行时间很长的、同 UI 有关的任务。 每个任务对应一个线程方法和单个后台线程（single-background-thread）方法在某些情形下都工作得非常理想。每个任务一个线程方法在只有少量运行时间很长的任务时工作得十分好。而只要调度可预见性不是很重要，则单个后台线程方法就工作得十分好，如低优先级后台任务就是这种情况。然而，大多数服务器应用程序都是面向处理大量的短期任务或子任务，因此往往希望具有一种能够以低开销有效地处理这些任务的机制以及一些资源管理和定时可预见性的措施。线程池提供了这些优点。 工作队列 就线程池的实际实现方式而言，术语“线程池”有些使人误解，因为线程池“明显的”实现在大多数情形下并不一定产生我们希望的结果。术语“线程池”先于Java 平台出现，因此它可能是较少面向对象方法的产物。然而，该术语仍继续广泛应用着。 虽然我们可以轻易地实现一个线程池类，其中客户机类等待一个可用线程、将任务传递给该线程以便执行、然后在任务完成时将线程归还给池，但这种方法却存在几个潜在的负面影响。例如在池为空时，会发生什么呢？试图向池线程传递任务的调用者都会发现池为空，在调用者等待一个可用的池线程时，它的线程将阻塞。我们之所以要使用后台线程的原因之一常常是为了防止正在提交的线程被阻塞。完全堵住调用者，如在线程池的“明显的”实现的情况，可以杜绝我们试图解决的问题的发生。 我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和 Eclipse插件——RunJettyRun的安装与使用 关于Jetty与Eclipse的集成，网上很多都是使用Eclipse的一个自动安装功能——Software Update。个人不太喜欢这种方式。这种安装方式有点问题：第一，需要网络流畅；第二，安装很慢。 所以，我选择手动安装的方式。只需要下载一个很小的jar包。 也许有人会说，MyEclipse不是已经以 Servers 的形式集成了Jetty了吗？就像Tomcat一样。 以插件的形式集成的Jetty的好处是：不用部署（deploy）项目，直接选中项目，右键 - Run As / Debug As 就可以运行。 话不多说。开始Jetty的HelloWorld之旅吧！ 下载 插件下载地址：runjettyrun_1.3.1.jar 安装 1、将下载的runjettyrun_1.3.1.jar文件复制到 D:\eclipse \plugins 目录下。 2、重启Eclipse。 3、菜单栏选择 Run Run Configurations，出现如下图的界面。可以看到，多了一个 Jetty Webapp 分支。 使用 1、新建一个 Web Project 。可取名 JettyTest 。 2、选中项目中的 Java EE 5 Libraries ，右 键 > Build Path > Remove from Build Path 。（注意：这个一定要删掉。不然项目启动不起来。） 3、在项目自动生成的 index.jsp 文件里，Kettle开源ETL平台_安装配置及使用说明v1.1
Tomcat-JBoss-Weblogic-Jetty的区别和介绍
JAVA线程池原理333
Eclipse插件RunJettyRun的安装与使用
Hello World for Jetty!!!!!!
4、选中项目，右键 > Run As (Debug As) > Run Jetty ，你会看到控制打印了些启动信息。 5、测试 打开IE，在地址栏中输入 http://localhost:8080/JettyTest ，你会看到如下的页面： 6、其他配置 Jetty的默认端口是 8080 。如果想要更改，回到本文第一张图片 的 Debug/Run Configurations ，如图。点开 Jetty Webapp 前的 + 标志，你会看到有了个 JettyTest 。因为前面运行过了，所以它自动加载了。如果没有也没关系，可以自己新建（如图，左上角的第一个）。
Java多线程技术及案例
Java多线程技术及案例 进程和线程： 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多个任务（程序）。 多线程是指在同一程序中有多个顺序流在执行。 Java中多线程的多种实现方式 Java中有多种多线程实现方法，主要是继承https://www.wendangku.net/doc/2014072914.html,ng.Thread类的方法和 https://www.wendangku.net/doc/2014072914.html,ng.Runnable接口的方法。 继承Thread类 Thread是https://www.wendangku.net/doc/2014072914.html,ng包中的一个类，从这个类中实例化的对象代表线程，启动一个新线程需要建立一个Thread实例。 使用Thread类启动新的线程的步骤如下： 1.实例化Thread对象 2.调用start()方法启动线程 构造方法：
public Thread(String threadName); public Thread(); 例程： publicclass Thread1extends Thread{//定义一个类继承Thread privateint count=1000; publicvoid run(){//重写run方法 while(true){ System.out.print(count+" "); if(--count==0){ return; } } } publicstaticvoid main(String[] args){ Thread1 th1=new Thread1();//实例化继承了Thread的类 Thread1 th2=new Thread1(); th1.start();//调用start()方法， th2.start(); for(int i=0;i<1000;i++){ System.out.print("A "); } }
Jetty Netty对比性能测试
Jetty Netty对比性能测试 测试工具：Apache2 ab 测试客户端：192.168.12.143 CPU: Intel(R) Xeon(R) CPU E5410 @ 2.33GHz * 8 内存:16,406,980k total 测试服务器：192.168.199 CPU:Intel(R) Xeon(R) CPU E5520 @ 2.27GHz * 16 内存: 49,432,720k total JVM: java version "1.6.0_24" Java(TM) SE Runtime Environment (build 1.6.0_24-b07) Java HotSpot(TM) Server VM (build 19.1-b02, mixed mode) JVM启动参数： -Xss128k -Xms2048m -Xmn1024m -Xmx2048m -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -verbose:gc -XX:+PrintGCDetails 其他： Netty: bossExecutor, workerExecutor均使用单独的CachedThreadPool启动：NioServerSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool(); 业务交给单独的CachedThreadPool处理。 Jetty:版本：jetty-hightide-8.0.0.M2，默认配置。 AB:总共发送40000个请求。 并发量测试 无业务，返回数据小于1KB。并发与吞吐量：
jetty的基本架构
jetty的基本架构 Jetty 的基本架构 Jetty 目前的是一个比较被看好的 Servlet 引擎，它的架构比较简单，也是一个可扩展性和非常灵活的应用服务器，它有一个基本数据模型，这个数据模型就是 Handler，所有可以被扩展的组件都可以作为一个 Handler，添加到Server 中，Jetty 就是帮你管理这些 Handler。 Jetty 的基本架构 下图是 Jetty 的基本架构图，整个 Jetty 的核心组件由 Server 和Connector 两个组件构成，整个 Server 组件是基于 Handler 容器工作的，它类似与 Tomcat 的 Container 容器，Jetty 与 Tomcat 的比较在后面详细介绍。Jetty 中另外一个比不可少的组件是Connector，它负责接受客户端的连接请求，并将请求分配给一个处理队列去执行。 图 1. Jetty 的基本架构Jetty 中还有一些可有可无的组件，我们可以在它上做扩展。如 JMX，我们可以定义一些 Mbean 把它加到 Server 中，当Server 启动的时候，这些 Bean 就会一起工作。 图 2. Jetty 的主要组件的类图从上图可以看出整个 Jetty 的核心是围绕着Server 类来构建，Server 类继承了 Handler，关联了 Connector 和 Container。Container 是管理 Mbean 的容器。Jetty 的 Server 的扩展主要是实现一个个 Handler 并将 Handler 加到 Server 中，Server 中提供了调用这些 Handler 的访问规则。 整个 Jetty 的所有组件的生命周期管理是基于观察者模板设计，它和Tomcat 的管理是类似的。下面是 LifeCycle 的类关系图每个组件都会持有一个观察者（在这里是 Listener 类，这个类通常对应到观察者模式中常用的 Observer 角色，关于观察者模式可以参考《Tomcat系统架构与设计模式，第2部分:设计模式分析》一文中关于观察者模式的讲解）集合，当 start、fail 或 stop 等事件触发时，这些 Listener 将会被调用，这是最简单的一种设计方式，相比 Tomcat 的 LifeCycle 要简单的多。Handler 的体系结构 前面所述 Jetty 主要是基于 Handler 来设计的，Handler 的体系结构影响着整个 Jetty 的方方面面。下面总结了一下 Handler 的种类及作用：
jetty服务器的安装和部署、新 增到开机启动服务
Jetty的首页地址是https://www.wendangku.net/doc/2014072914.html,/jetty/，点击Downloads 进入下载介绍页面，由于Jetty7之后，托管服务有Eclipse接替，所以jetty6.1之前（包含6.1）继续由Codehaus提供下载服务，在该页面的下方有如下信息： 版本 Java HTTP Servlet JSP Status Notes Jetty-8 eclipse 1.6- HTTP/1.1 RFC2616 3.0 2.2 Development Standardized async Jetty-7 eclipse 1.5- HTTP/1.1 RFC2616 2.5 2.1 Almost stable org.eclipse.jetty Jetty-6.1 1.4-1.6 HTTP/1.1 RFC2616 2.5 2.1 or 2.0 Stable Async SSL, AJP, cometd, testing Jetty-6 1.4-1.5 HTTP/1.1 RFC2616 2.5 2.1 or 2.0 Deprecated Continuations, IOC, NIO, dynamic buffers, smaller, faster, better Jetty-5.1 1.2-1.5 HTTP/1.1 RFC2616 2.4 2.0 Stable J2EE 1.4 Compliance tested, optimizations, geronimo integration. Jetty-5.0 1.2-1.4 HTTP/1.1 RFC2616 2.4 2.0 Deprecated Schema, JettyPlus Jetty-4.2 1.2-1.4 HTTP/1.1 RFC2616 2.3+ 1.2 Mature JettyPlus Jetty-4.1 1.2-1.4 HTTP/1.1 RFC2616 2.3 1.2 Deprecated JAXP1.1, AJP13(mod_jk) Jetty-4.0 1.2 HTTP/1.1 RFC2616 2.3 1.2 Deprecated Jetty-3.1 1.2 HTTP/1.1 RFC2068 2.2 1.1 Ancient JMX Jetty-3.0 1.2 HTTP/1.1 RFC2068 2.2 1.1 Fossilized Jetty-2.4 1.1 HTTP/1.0 RFC1945 2.1 1.0 Legendary Jetty-1.0 1.0 HTTP/1.0 RFC1945 - - Mythical 本书讨论的Jetty版本是6.1，也是目前使用最多的稳定版本，我们到https://www.wendangku.net/doc/2014072914.html,/jetty/jetty-6.1.22/下载6.1系列最新的6.1.22版本：
Jetty 源码分析
Jetty 源码分析 在文库看到一个关于jetty源码分析的PDF文档，发现该文档根本不全，遂在 网上又找到了关于此文档内容的网站，将其网页内容拷贝了出来，供大家浏览！ 一、总括 你了解Jetty 吗，就像我们所熟知的Tomcat一样, Jetty是一个免费的开放源码的100%纯Java的Http服务器和Servlet容器。 Jetty具备以下特点： 快速高效 。Jetty是最快的Servlet服务器之一 。Jetty可以处理上千个并发连接 小巧嵌入 。Jetty的jar只有600多K 。可动态嵌入到应用程序，适合开发web2.0等应用 应用广泛 。开源项目有Geronimo, JBoss, JOnAS等 。商业项目有IBM Tivoli, Sonic MQ and Cisco SESM等 可到Jetty网站 https://www.wendangku.net/doc/2014072914.html,/jetty/查看最新信息 本文将通过对Jetty最新稳定版Jetty5.1.5RC2 源码的研究，向读者展示Jetty在设计方面使用的不同设计理念, 希望对广大开发者在设计自己的系统时有所帮助。 Jetty按照功能可以分为四个主个主要的部分,HttpServer, HttpContext,HttpHandler,HttpListener,详见如下类图:
<图1-1> 二、HttpServer及配置 对于初次接触Jetty的人一定会对上图感到迷惑，其实在Jetty中HttpServer是一个服务器的核心控制类, 我们可以看到，其它的组件类都是由该类扩展开来，HttpServer的作用就是在一系列的监听器类和处理器类之间搭起了一个桥梁,有效的控制着消息在系统内的传递,如下图: <图1-2 > HttpServer职责是接受从HttpListener传递过来的request(请求),HttpServer通过对request的Host(主机)或Path(路径)进行匹配,然后分发给相应的HttpContext(可以理解为一个web application)。
JAVA WEB入门之一：搭建JFINAL框架
Java web入门之一：搭建JFinal框架 一、创建项目 1、启动eclipse，切换至java EE视图 2、创建Dynamic Web Project项目，项目名自定，示例项目名为webdemo，Target Runtime 选None，Dynamic web module version选择2.5
3、修改Default Output Folder，推荐输入WebRoot\WEB-INF\classes 特别注意：此处的Default out folder必须要与WebRoot\WEB-INF\classes目录完全一致才可以使用JFinal集成的Jetty来启动项目。
4、修改Content directory，推荐输入WebRoot 注意：此处也可以使用默认值WebContent，但上一步中的WebRoot\WEB-INF\classes则需要改成WebContent\WEB-INF\classes才能对应上。
5、放入JFinal库文件 将jfinal-1.9-bin-with-src.jar与jetty-server-8.1.8.jar拷贝至项目WEB-INF\lib下即可。注意：jetty-server-8.1.8.jar是开发时使用的运行环境，生产环境不需要此文件。
6、修改web.xml 将如下内容添加至web.xml
手把手教你做一个java线程池小例子
废话不多说开整 我用的是eclipse（这应该没多大影响） 建一个工程java工程和web工程都行然后建一个包建一个类带main方法 首先贴出来的是内部类 //继承了runnable接口 class MyTask implements Runnable { private int taskNum; public MyTask(int num) { this.taskNum = num; } @Override public void run() { System.out.println("正在执行task "+taskNum); try { //写业务 Thread.currentThread().sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("task "+taskNum+"执行完毕！"); } } 接下来就是这个类 public class testOne { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 7, 10, https://www.wendangku.net/doc/2014072914.html,LISECONDS, new ArrayBlockingQueue
for(int i=0;i<15;i++){ MyTask myTask = new MyTask(i); executor.execute(myTask); System.out.println("线程池中线程数目： "+executor.getPoolSize()+"队列等待执行的任务数目："+ executor.getQueue().size()+"已经执行完别的任务数目： "+executor.getCompletedTaskCount()); } executor.shutdown(); } } 接下来在说明一下ThreadPoolExecutor的参数设置ThreadPoolExecutor(int corePoolSize,//线程池维护线程的最少数量 int maximumPoolSize,//线程池维护线程的最大数量 long keepAliveTime,//线程池维护线程所允许的空闲时间 TimeUnit unit, 线程池维护线程所允许的空闲时间单位 BlockingQueue workQueue,线程池所使用的缓存队列 RejectedExecutionHandler handler线程池对拒绝任务的处理策略 ) handler有四个选择： ThreadPoolExecutor.AbortPolicy() 抛出java.util.concurrent.RejectedExecutionException异常 ThreadPoolExecutor.CallerRunsPolicy() 重试添加当前的任务，他会自动重复调用execute()方法 ThreadPoolExecutor.DiscardOldestPolicy() 抛弃旧的任务 ThreadPoolExecutor.DiscardPolicy() 抛弃当前的任务 上面是一个例子接下来再来一个例子
jetty下载启动配置详解及和maven结合pom配置
1、jetty下载地址 首页 https://www.wendangku.net/doc/2014072914.html,/jetty/选择下载版本下载，下载下来之后解压 2、我是windows 启动命令java -jar start.jar etc/jetty.xml 默认8080 端口访问http://localhost:8080/test/test自带工程出现welcome页面 把自己的项目拷贝到D:\jetty-6.1.0\webapps （我的是d 盘，自己的位置自己改下）执行启动命令然后访问 制作Jetty bat启动文件 @ECHO OFF D: cd D:\jetty-6.1.0 echo 启动Jetty... pause java -jar start.jar etc/jetty.xml 3、Jetty服务配置etc\jetty.xml 修改访问端口：
java深入理解线程池
深入研究线程池 一.什么是线程池? 线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合. 注意这里用了线程集合的概念是我生造的,目的是为了区分执行一批应用逻辑的多个线程和 线程组的区别.关于线程组的概念请参阅基础部分. 一般而言,线程池有以下几个部分: 1.完成主要任务的一个或多个线程. 2.用于调度管理的管理线程. 3.要求执行的任务队列. 那么如果一个线程循环执行一段代码是否是线程池? 如果极端而言,应该算,但实际上循环代码应该算上一个逻辑单元.我们说最最弱化的线程池 应该是循环执行多个逻辑单元.也就是有一批要执行的任务,这些任务被独立为多个不同的执行单元.比如: int x = 0; while(true){ x ++; } 这就不能说循环中执行多个逻辑单元,因为它只是简单地对循环外部的初始变量执行++操作. 而如果已经有一个队列 ArrayList al = new ArrayList(); for(int i=0;i<10000;i++){ al.add(new AClass()); } 然后在一个线程中执行: while(al.size() != 0){ AClass a = (AClass)al.remove(0); a.businessMethod(); } 我们说这个线程就是循环执行多个逻辑单元.可以说这个线程是弱化的线程池.我们习惯上把这些相对独立的逻辑单元称为任务. 二.为什么要创建线程池? 线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么 线程池的最重要的特征也就是最大程度利用线程. 从编程模型模型上说讲,在处理多任务时,每个任务一个线程是非常好的模型.如果确实可以这么做我们将可以使用编程模型更清楚,更优化.但是在实际应用中,每个任务一个线程会使用系统限入"过度切换"和"过度开销"的泥潭. 打个比方,如果可能,生活中每个人一辆房车,上面有休息,娱乐,餐饮等生活措施.而且道路交道永远不堵车,那是多么美好的梦中王国啊.可是残酷的现实告诉我们,那是不可能的.不仅每个人一辆车需要无数多的社会资源,而且地球上所能容纳的车辆总数是有限制的. 首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.
JettY 部署Web应用程序
第5章部署Web应用程序 当我们编写好一个web应用程序，如何交付给Jetty容器来运行呢？这也就是所谓“部署web应用程序”。 本章将介绍如何在Jetty中部署web应用，以及在Jetty的构架体系中是如何实现web应用部署的。 5.1 常用术语 为了使本章中讨论的内容能得到大家一致的理解，本节先明确一些专业术语，避免大家造成误解。 web应用程序（Web Application） 经常会说到这个词，大家也不难理解，就是由一组文件构成的集合，这些文件可能包含html文件、图像文件、java编译后的class文件，配置文件等等所有可能出现的文件。符合Servlet规范的应用程序还要求目录下存在一个WEB-INF的文件夹，在里面还必须存在一个web.xml的web部署配置文件，关于这个目录和web.xml的内容格式都是Servlet规范中定义的。根据Servlet规范我们还可以web应用程序整个目录打包成 war文件。 上下文（Context） 上下文是我们经常听到的词汇，可以使用在各种专业场合，但当我谈论web应用程序的时候，是这样的意思。 首先看一个名为Example的web应用程序的访问URL， https://www.wendangku.net/doc/2014072914.html,/example /index.jsp。可以发现要访问这个Example应用，所有的路径都需要加前缀“/example”，换句话说，就是该应该的访问地址都符合 https://www.wendangku.net/doc/2014072914.html,/example/* 这种模式。所有已https://www.wendangku.net/doc/2014072914.html,/example/开头的请求都将有Example应用程序处理。 这就是上下文的概念了。有了上下文的概念后，一个web服务下就可以部署多套不同的web应用程序了，且不同的应用程序不会造成混乱。 上下文路径（Context Path） 在术语上下文的中，我们举例的“/example”就是上下文路径。同一个服务器下的不同的web应用就应该有不同的上下文路径。 注意：上下文路径必须以“/”开头，且不能以“/”结尾。
Jetty 9嵌入式开发手册
Jetty 9嵌入式开发手册 Jetty有一个标语，“不要部署你的应用在Jetty上，部署Jetty在你的应用中”。这意味着可选择使用Jetty捆绑你的应用作为一个标准 WAR进行部署。Jetty设计成一个软件组件，可以实例化并且使用在Java程序中，例如：如何POJO。但是另外一种方法，以嵌入式模式运行 Jetty，这意味着把HTTP模块放入到你的应用中，而不是把你的应用放入到HTTP服务中。 本教程引导你逐步从最简单的Jetty服务实例到使用标准部署描述运行多个Web应用。大部分示例的源代码是标准Jetty项目的一部分。 在学习该教程之前，完成一个HelloWorld教程是值得的。该教程可以在“嵌入式Jetty网络研讨会记录”中找到。 Jetty版本：本教程的代码来自于Jetty7，但是也应该在Jetty 8中可以使用。对于最新的稳定版本，参考最新发行版的链接代码。可能与本教程中给出的代码例子有稍微的不同。 概述 为了嵌入Jetty服务，通常执行下面的步骤： 1）创建一个服务 2）添加和配置连接器 3）添加和配置处理器 4）添加和配置Servlet、Webapp到处理器 5）启动服务 6）等待（join服务防止主线程退出） 创建一个服务 下面的代码来自于SimplestServer.jar，实例化和运行一个最简单的Jetty服务 https://www.wendangku.net/doc/2014072914.html,/jetty/stable-9/xref/org/eclipse/jetty/emb edded/SimplestServer.html public class SimplestServer
SCA软件架构
SCA软件架构 一、SCA(Service Component Architecture)软件架构的概述SCA是一个开发SOA(Service-Oriented Architecture)面向服务应用的简单模型规范，它描述用于使用SOA构建应用程序和系统的模型。它可简化使用SOA进行的应用程序开发和实现工作。SCA仅仅是个规范，各个涉及SOA技术的公司的实现也各不相同。 SCA是由Open Service Oriented Architecture collaboration 提出的一种组件化的面向服务编程模型，并于2007年正式捐献给OASIS组织。 SCA提供了服务组件模型、装配模型和策略框架来支持各种异构应用的封装和集成。同SCA并列提出的SDO规范，定义了SOA应用程序中访问各种异构数据源的方法。组件可以以各种不同的协议发布服务，包括SOAP、RMI、REST、JMS，甚至可以是虚拟机内的对象直接调用。组件可以使用多种技术实现, 包括EJBs, Java POJOs ，Spring Beans，BPEL process ， COBOL ，C++， PHP … SCA中，最重要的一个概念是Service----服务，它的内涵是独立于具体的技术。因此，SCA不会称之为 Java组件架构，或Web Service 组件架构。所谓的具体技术，主要有两层含义：一是程序语言，而是传输协议。 现有的组件是和传输协议紧密耦合的。比如EJB组件采用的是RMI 传输协议，Web Service组件采用的是SOAP传输协议。SCA组件则能
自由地绑定各种传输协议。 SCA是对目前组件编程的进一步升华，其目标是让服务组件能自由绑定各种传输协议，集成其他的组件与服务。 SCA与传统的业务组件最大区别在于SCA实现了两个功能：一是组件和传输协议的分离，二是接口和实现语言的分离。 二、SCA规范基础知识 SCA编程模型是高扩展性和语言中立的，它易于被扩展为多种实现语言技术JAVA，C++，BPEL，PHP， Spring等，多种远程访问bindings 包括Web Service，JMS， EJB，JSON RPC等，多种主机环境例如Tomcat，Jetty，Geronimo，OSGI等。SCA分隔式架构可以使开发者更注重业务逻辑，而不必要关注诸如可靠性，安全，事务等系统属性，这些属性都配置到配置文件中。SCA的组成部分如下图所示： （1）Component
Android端i-jetty服务器开发(一)
一、i-jetty简介 介绍： popular Jetty open-source platform.Having a "personal" webserver on your phone opens up a world of possibilities, letting you run your favourite existing webapps in your mobile environment. Moreover, as webapps developed for i-jetty have access to the Android API, this means that you can bring the contents of your mobile phone to your normal desktop browser. To demonstrate the possibilities, we've created a "Console" webapp that interfaces to the data on your mobile device. You don't need any special software to synchronize the mobile data to your desktop computer - the i-jetty console webapp makes your on-phone info like contacts lists, call logs and media instantly available and manageable via your browser. We've packaged the Console webapp as an Android application so it can be conveniently downloaded and updated via the Android Marketplace. i-jetty can also dynamically download webapps from anywhere on the net. To help get you started, we've also created a "Hello World" webapp that is simpler than the Console webapp. You can either build it from src and install it locally, or you can point i-jetty to the pre-built hello.war on the download page. The apks for i-jetty and the i-jetty Console webapp are both available from the Android Marketplace, and also from the download page.
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接 最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket 的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。 具体实现方式见代码： 一、TCP方式： 1、服务端实现方式： TCP的服务端实现方式主要用到ServerSocket类，接收等待客户端连接的方法是accept(); 代码如下：类SocketServerTCP 1private int port=8823; 2private ServerSocket serverSocket; 3private ExecutorService executorService;//线程池 4private final int POOL_SIZE=100;//单个CPU线程池大小 5 6public SocketServerTCP(){ 7try{ 8serverSocket=new ServerSocket(port); 9executorService= Executors.newFixedThreadPool(Runtime.getRuntime() 10.availableProcessors()*POOL_SIZE); https://www.wendangku.net/doc/2014072914.html,("端口号为"+port+"的服务器启动"); 12}catch(IOException e){ 13 e.printStackTrace(); 14} 15} 16 17public void service(){ 18System.out.println("socket初始化成功！"); https://www.wendangku.net/doc/2014072914.html,("socket服务端初始化成功！"); 20while(true){ 21Socket socket=null; 22try{ 23//接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接