# java容器 java容器很很多，tomcat、jetty、jboss、resin、weblogic、webspere等等。 有收费的，也有开源免费的，性能可能是有些许差异的，理论上，收费的应该比免费的，性能要要一些。 但是，用开源免费的来做巨大访问量的（比如千万PV）应用，也是毫无问题的，当前我们所处的技术浪潮，性能的瓶颈一般都在数据库上，在硬盘的访问上，而不是网络请求和响应。 **已知互联网公司使用的java容器：** jetty：google、美团 tomcat：yougou.com jetty官网：[http://www.eclipse.org/jetty/](http://www.eclipse.org/jetty/) jetty源码：git clone https://github.com/eclipse/jetty.project.git 关于tomcat的博客：[http://blog.csdn.net/puma_dong/article/details/21875253](http://blog.csdn.net/puma_dong/article/details/21875253) [Jetty 的工作原理以及与 Tomcat 的比较](http://www.ibm.com/developerworks/cn/java/j-lo-jetty/) [Google App Engine转向了Jetty](http://www.infoq.com/cn/news/2009/08/google-chose-jetty/) # jetty日志 ### jetty的日志记录 本周遇到一个jetty日志的问题，看jetty的request.log日志中，我们post过来的参数没有记录，google了好久，没有答案，于是把jetty源码下载下来，看了看日志这部分：jetty-server/src/main/resource/org/eclipse/jetty/server/NCSARequestLog.java，发现日志中关于参数相关的日志，只记录了request.getUri()，也就是说只有get的参数才能记录到日志里面去，post的参数都不会记录到日志里面。 **相关帖子：** [http://wiki.eclipse.org/Jetty/Tutorial/RequestLog](http://wiki.eclipse.org/Jetty/Tutorial/RequestLog) ### 启动过程中一个日志输出的问题 启动过程中，jetty的INFO级别及以上的日志，会打印到IDE控制台（比如Eclipse），突然有一天，日志不再打印到IDE控制台，而是到某个地方后，重定向到了logs/jetty.log.2015-06-10，如图：  开始发现这个日志和mms-boot-0.8.jar中的配置一致，截图如下：  所以把问题的原因定义为：jetty定义的重定向，对于控制台的输出重定向到了文件（实际jetty8.xml仅仅是对System.out/error进行了重定向）。 后来了解到，其他的项目也是同样的启动方式，没有这个问题。 于是重新查原因，对比hotel-campaigns和hotel-cms的日志的不同，开始时有“先入为主”的思维定势，潜意识相信是jetty8.xml再捣鬼，所以对比两个项目的依赖mms的版本、及执行jetty8.xml处的日志，修改log4j.xml配置文件进行多种办法的尝试，没有找出问题。 结合下午发现的log4j.xml配置文件不生效，可以确定：IDE启动hotel-campaigns项目时，对于slf4j的实现，用了logback，为什么突然用了logback呢？ 结合pom.xml，可以看到：  于是exclusions 这个jar，问题解决。 **参考文章：** [http://www.slf4j.org/codes.html#multiple_bindings](http://www.slf4j.org/codes.html#multiple_bindings) [http://www.slf4j.org/manual.html](http://www.slf4j.org/manual.html) # 嵌入式Jetty和RunJettyRun插件 使用RunJettyRun插件，项目运行正常，截图如下： 使用嵌入式方式运行，打不出启动成功的标记，截图如下： 开始尝试解决问题： 1、由于“springmvc”是web.xml里面关于SpringMVC的servlet，尝试把SpringMVC相关的内容都去掉，依然没有打出启动成功的日志 2、尝试着访问了一下antispider-server提供的Thrift服务和Web服务，结果都是正常的，很是疑惑，这个时候怀疑：RunJettyRun插件（这相当于Jetty容器）和Bootstrap（这相当于Jetty内嵌），对于SpringMVC或者Web项目的处理方式，有很大不同，导致没有正常启动完毕。 评：这实际是由于对Jetty理解不深刻，胡乱猜忌Jetty了，如果作为容器和嵌入式，有很大的差别，这简直是不可想象的。 由于没有解决问题，结合Bootstrap源码，关注以上图示中的“第一点”和“第二点” 第一点：这一点没啥好说的，就是src/main/resource下没有config.properties，对于结果没有影响，期间经历一个小插曲，hotel-campaigns-web项目，没有config.properties文件，也没打这行日志，经查是因为依赖的sinai.client里面有config.properties 第二点：这一点因为使用RunJettyRun插件时没有这个日志，所以被高度怀疑，差异了一些资料，但是依然没有解决 http://stackoverflow.com/questions/22938689/info-no-spring-webapplicationinitializer-types-detected-on-classpath http://stackoverflow.com/questions/16321819/no-spring-webapplicationinitializer-types-detected-on-classpath http://steveliles.github.io/setting_up_embedded_jetty_8_and_spring_mvc_with_maven_and_no_xml.html http://hitmit1314.iteye.com/blog/1315816 3、万不得已，新建一个单纯的aitispider-test项目，使用Bootstrap运行，并逐渐增加antispider-server的配置文件，终于在一步增加log4j.xml时，问题重现，找出原因： 4、"org"中，“ERROR”以下级别的日志被过滤了，用RunJettyRun插件，启动成功，是oejs包打印的，所以能显示；而用嵌入式Jetty，启动成功是org包打的，所以被过滤掉了，截图如下： 5、故事到此就结束了，但这个经历，加深了对嵌入式Jetty的理解：服从一套规范，实现一组标准，帮我们实现高效的Web通讯。如果写过ServerSocket通讯程序，会对嵌入式Jetty更深入的了解。 另外一个没有微观佐证的问题，关于Maven解决冲突的方式： 对于，这个问题，我使用准确告诉maven使用版本的方式解决（这是最标准、明确的方式，本身对于pom.xml就应该进行准确的定义，不应该依赖Maven自定义的方式帮我们解决冲突）：

设计模式，先看名字，设计，模式，目的是为了设计，为了设计给出一些定义出来的，总结出来的，抽象出来的办法，叫做模式。 设计是什么？软件构建中的设计，承前（需求分析、产品定义、架构选择），启后或者伴随（编码、测试），包含结构、包、类、子程序，而模式讲的就是这些东西。 # 设计模式是一种思想 这次关于设计模式的分享不是纯技术，是思想。 思想的东西，很难讲，需要听众具备恰当的理解层次，而这种层次的进化，远比一种技术或者工具的进步难以捉摸，有时十年循环不如一夕顿悟。 设计模式是一种思想，是与语言强相关的。 在低级语言（机器、汇编）中，不会有模式；在未来的高级语言中，会从语法层面实现模式（模式本身是语义层面的）；在当前广泛使用的高级语言（Java）中，模式被基于解决特定场景的问题，抽取出来，大行其道，广泛使用。 低级语言和高级语言，没有一条分界线，是逐渐进化的。每个程序员都处于其所在的层次上（或者叫境界），处于一个层次，能理解低层次的落后（比如机器语言），但无法理解高层次的先进。这就是《黑客与画家》中所说的Blub困境。 引申到职场、人生和世界观，每个人也都活在自己的抽象层次中，能看懂低层次的落后，但无法理解高层次先进在何处。从境界高低来讲，是有对错的，但如果没有进化到一个层次，也是无法从根本上被说服的，需要到达，才能认知。 # 面向对象的三大特征 面向对象三大特性：封装、继承、多态。 封装，往往和抽象、高内聚、一致的抽象层次等概念联系在一起。 继承是一条竖线，在编程中很常用，但更常用的是包含（"has a"），从广义上来说，甚至可以认为"has a"，也是一种适配器模式。能用包含，则不用继承，因为继承引入了继承体系上的复杂性。 多态是继承基础上的重写，加上父类变量对子类对象的引用。可以认为多态，是Java这种静态类型语言，向动态类型语言（比如ruby/python），迈出的一小步。 抽象： 抽取事物最本质形成概念。 并运用概念进行推理、判断的思维活动。 抽象交流。 模拟能力,想象能力。 表达能力(口头,文字,文言文和琼瑶剧)。 字、词、句、段. # 单例 单例是最重要的一种设计模式。是无状态的逻辑。无状态是业务层实现高可用和可伸缩的重要手段。  ### 单例一：基础 演示了一个最简单的单例、延迟初始化的单例，以及双重检查机制的单例的代码写法。 对于双重检查机制的单例，减小了线程间的碰撞（synchronized），只有前几个线程才可能碰撞，锁的力度小了，性能提高了，线程也安全了。 对于双重检查单例，没有实际意义，只有历史意义，增加Java程序员对于所犯错误的洞察力，如果写单例，有最简单的写法就够了。 过去陈旧的JDBC操作数据库编码过程中，有代码Class.forName("com.mysql.jdbc.Driver")，目的是把类装载到JVM的PermGen区域，这样类的静态方法就可以使用了，这和类的初始化没关系。 显式API初始化也有好处，比如web系统，init写到监听里面去。把初始化放到init里面。清晰了。 ### 单例二：Spring Java生态中，除了JDK之外，最基础的框架是Spring。Spring框架的高层抽象很多，帮我们解决了很多场景下的技术问题。 Spring的基础的、底层的思想是控制反转（Invest Of Control）、依赖注入（Dependency Injection），可以认为是单例的一种表现形式。说的是两个单例对象之间的关系。 控制反转，反转的控制权，原来是谁用谁有控制权；控制反转的思想是，你可以用，但是我依然有初始化自己的控制权。 依赖注入，谁要用（就是谁依赖），谁负责把别的类引入进来。 写简简单单的3个类，能解释Spring的思想。读取配置文件或者扫描Spring注解，利用反射实例化类，放置到一个Map中，这就是Spring IOC的基础过程了。 结合《Spring技术内幕：深入解析Spring架构与设计原理》，花费1个星期简要看看Spring源码，发现就是这样的。 ### 单例三：状态和线程安全 参考文章：[http://www.iteye.com/topic/960532](http://www.iteye.com/topic/960532) 有状态：有状态就是有数据存储功能。 无状态：无状态的都是功能操作，对象是线程安全的。 几个概念：维护全局状态、控制状态读写、线程安全。 以上指的是状态的线程安全。对于HashMap的解释，如果从状态的线程安全绝度解释，也是说的通的，HashMap里面有数组，也是有状态的。 ### 单例四：数据库 状态固化的单例：其实就是数据库，每一行可以看作一个单例，它是系统唯一的，也可以是线程安全的。 跨JVM的单例：实现方式有很多，只要满足有锁的持久化即可。 多进程安全的单例：说的是数据库锁。 以上都是分布式的思想。 自从有了数据库，程序员就变得廉价了。 # 其他的创建模式 工厂、抽象工厂、建造者、原型。 工厂：创建对象很复杂，所以需要一个创建对象的工厂。 建造者：比如耐克工厂，有鞋帮，有鞋带，合起来之后是一个完整的整体，这就是建造者模式。 什么时候用单例，什么时候用单一状态（类的单一状态）。 为什么不全部用static，而用单例？有一种解释是：控制反转、依赖注入，这种思想。保留了初始化自己的控制权。如果完全的工具类，没有初始化的需求，static就满足了。 # 结构模式 开闭原则：对修改封闭，对扩展开放。 包装（Composite）：不想改变原代码，又想实现某些功能。 代理（Proxy）：举了一个监护人的例子，让吃才能吃。不改变语义，前前后后做点东西出来。 适配（Adapter）：adapter比proxy更牛逼一些，它改变了语义，些许进行改造。 外观（Facade）：和代理先比，结构相似，语义不同。 继承是标签，接口表现了具备什么能力。 **面向对象一直争论的问题：** 是用包含（用你的能力，但不打你的标签，"has a"），还是用继承（"is a"）。一种观点认为，继承对于软件设计，引入了复杂性。 # 行为模式 行为模式，描述的是对象的动作。局限性，必须顺序执行。？？？ 模板：高层的流程抽象。 责任链：演示一个通过注解定义执行顺序的历程。好处：1.动态的组织流程；2. 代码控制流程的执行；深化一下，就是工作流。 以上两种模式，是重构的利器，加上反射，就可以写通用功能的中间件了。 # 不是结束 设计模式是很枯燥的，记住三件事：创建一个对象、包装一个对象、根据当前的场景，信手拈来。 农夫山泉：我们不生产水，我们只是大自然的搬运工。程序员不能成为农夫山泉，不能只是jar包的搬运工。要学会创造，一边搬砖的时候，一边想一想，如何创造出更优秀的东西。 单例/静态、线程安全、无状态，是从3个维度对软件问题的描述，单例/静态是思想角度（单例是设计模式，是语义层面的思想，静态是编程语言从语法角度固化的思想），线程安全是技法角度（是一种基于现代的硬件基础的、常见的、需要解决的，重要的问题场景），无状态是数据角度（无状态的类，实际就是不具备数据存储能力的类）。 # 大师的话（linus) 烂程序员关心的是代码。好程序员关心的是数据结构和它们之间的关系。 面向对象语言以对象为核心，加一些相关联的方法，简直是呓语。 重要的东西应该是数据结构，对象本身有啥重要？ 真正有意思的，是在不同类型的不同对象交互而且有锁规则的时候。 但是，即使是这时候，封装什么“对象接口”也绝对错误，因为不再是单一对象的问题了。 他的结论是，面向对象解决的都是一些小问题。 这位大师是写操作系统的，从他的角度来看，自然是正确的，即使不从他的角度，我们也可以认识到数据结构的重要性。 [http://www.csdn.net/article/1970-01-01/2824040](http://www.csdn.net/article/1970-01-01/2824040)

魔法类的玄幻小说中，经常有个“猪脚”特别厉害，别人都用顶级的寒冰箭或者大火球，他不用，他只用一级的寒冰箭，恰到好处的使用，瞬发的使用，特别厉害。 为什么他能做到呢？因为他悟出了一种叫做“神之本源”或者“力量之源”的东西，掌握了魔法的本质，操控程度达到了极致，故而就厉害到了极致，成了“猪脚”。 本篇的讲座，对于Java并发来说，也是这样一种东西，让我们从最底层，从硬件级别，了解Java并发的本质，就好像我们掌握了“神之本源”。 # 现代计算机 先讲一下现代计算机（2015年之前）的发展现状，架构的解决方案、语言的低级特性，本质上是基于硬件的当前现状产生的。 ### 计算 现代计算机中，已经不追求CPU的时钟频率更高，而是朝着多核的方向发展。因为CPU已经快得离谱，追求更快对于日常应用意义不大，故而更追求多核、并行计算。 在Core 2 3.0 GHz上，大部分简单指令的执行只需要一个时钟周期，也就是1/3纳秒。 | **数据读取位置** | **花费CPU时钟周期** | **花费的时间（单位纳秒）** | |-----|-----|-----| | 寄存器 | 1 cycle | 1/3 | | L1 Cache | 3-4 cycles | 0.5-1 | | L2 Cache | 10-20 cycles | 3-7 | | L3 Cache | 40-45 cycles | 15 | | 跨槽传输 |   | 20 | | 内存 | 120-240 cycles | 60-120 |   参考文章： [http://duartes.org/gustavo/blog/post/what-your-computer-does-while-you-wait/](http://duartes.org/gustavo/blog/post/what-your-computer-does-while-you-wait/) ### 速度 对于速度，有个形象的比喻，如果，我们把CPU的一个时钟周期看作一秒，则： 从L1 cache读取信息就好像是拿起桌上的一张草稿纸（3秒）； 从L2 cache读取信息就好像是从身边的书架上取出一本书（14秒）； 从主存中读取信息则相当于走到办公楼下去买个零食（4分钟）； 硬盘寻道的时间相当于离开办公大楼并开始长达一年零三个月的环球旅行。 ### 缓存 缓存无处不在，不论是硬盘、网卡、显卡、Raid卡、HBA卡，都有缓存；缓存是比较容易的解决性能问题的简单方案，非常奏效，非常管用。 通过一级一级的缓存，来增加速度，比如： CPU的L1只有512K，L2是2M，L3只有好的服务器才有，是18M，L3很贵； 硬盘的缓存，一般只有64M，通过这个64M的缓存来增加速度。 **引申一个硬盘的问题：** 如果掉电了呢？ 服务器硬盘，可以通过硬盘内部电池保证缓存内容可以写到盘片上去，而家用计算机硬盘是做不到的，这也是价格差别很大的原因之一。 扩展一下，EMS磁盘阵列，做的很好，很快，是通过多磁头技术，减轻某一个磁盘的压力，内部也有缓存。 关于Cache，在架构设计时，经常要解决的一个问题就是：读和写的不安全感。写的时候要保证持久化设备和Cache都写了，读的时候，只读Cache。而服务器端的设备，比如上面说的服务器硬盘，这些问题都是考虑到了的。 ### CAS CAS，Campare And Swap，所有的现代CPU都支持。也是各种语言中，无锁算法，无锁并发实现的根基。 这是CPU硬件级别的，OS也不知道，所以这种实现方式能带来性能上的一定提升，也有副作用。 CAS提供了在激烈争用情况下更佳的性能，换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。 但是，这是给高级用户准备的，慎用，只有当深切了解确实是需要的场景时，才可用。 参考文章： [JDK 5.0 中更灵活、更具可伸缩性的锁定机制](http://www.ibm.com/developerworks/cn/java/j-jtp10264/index.html) # Java并发 用一个例程，来说明Java并发的问题，演示4种场景：线程不安全、synchronized、模拟CAS、原子类，如下： ~~~ import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; import sun.misc.Unsafe; /** * 演示Java并发的几种实现方法 * */ public class CompareAndSwapShow { private static int factorialUnSafe; private static int factorialSafe; private static int factorialCas; private static long factorialCasOffset; private static AtomicInteger factorialAtomic = new AtomicInteger(0); private static int SIZE = 200; private static CountDownLatch latch = new CountDownLatch(SIZE * 4); private static Object lock = new Object(); private static Unsafe unsafe; // 获取CasTest的静态Field的内存偏移量 static { try { Field field = Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (Unsafe) field.get(null); factorialCasOffset = unsafe.staticFieldOffset(CompareAndSwapShow.class.getDeclaredField("factorialCas")); } catch (Exception e) { e.printStackTrace(); } } /** * 存储每种计算方法的最终结果 */ private static Map factorialMax = new HashMap(); public static void main(String[] args) throws Exception { for (int i = 0; i < SIZE; i++) { new Thread(new IncreamUnSafe()).start(); new Thread(new IncreamSafe()).start(); new Thread(new IncreamCas()).start(); new Thread(new IncreamAtomic()).start(); } latch.await(); System.out.println("IncreamUnsafe Result：" + factorialMax.get("unsafe")); System.out.println("IncreamSafe Result：" + factorialMax.get("safe")); System.out.println("IncreamCas Result：" + factorialMax.get("cas")); System.out.println("IncreamAtomic Result：" + factorialMax.get("atomic")); } /** * 非线程安全的阶乘 * */ static class IncreamUnSafe implements Runnable { @Override public void run() { for (int j = 0; j < 1000; j++) { factorialUnSafe++; } recordMax("unsafe", factorialUnSafe); latch.countDown(); } } /** * 线程安全的阶乘 * */ static class IncreamSafe implements Runnable { @Override public void run() { synchronized (lock) { for (int j = 0; j < 1000; j++) { factorialSafe++; } } recordMax("safe", factorialSafe); latch.countDown(); } } /** * 用CAS算法实现的线程安全的阶乘，Java的原子类就是这么搞的，死循环，就是疯狂的压榨CPU * */ static class IncreamCas implements Runnable { @Override public void run() { for (int j = 0; j < 1000; j++) { for (;;) { int current = factorialCas; int next = factorialCas + 1; if (unsafe.compareAndSwapInt(CompareAndSwapShow.class, factorialCasOffset, current, next)) { break; } } } recordMax("cas", factorialCas); latch.countDown(); } } static class IncreamAtomic implements Runnable { @Override public void run() { for (int j = 0; j < 1000; j++) { factorialAtomic.incrementAndGet(); } recordMax("atomic", factorialAtomic.get()); latch.countDown(); } } /** * 记录每个线程的最终结果 * * @param key * @param target */ static synchronized void recordMax(String key, int target) { Integer value = factorialMax.get(key); if ((value == null) || (value < target)) { factorialMax.put(key, target); } } } ~~~ **重点解释一下场景1：**factorialUnSafe++，并不是原子的，会被分解是3条CPU指令：获取，加1，赋值；当CPU的调度，在这3个指令中间时，就可能产生线程安全问题。 附上一张图：  # 总结 为什么AtomicInteger的实现中，用死循环？原因是因为CPU太快了。其他一些概念，比如“自旋锁”，也是这个道理。 性能写到极致，是可以用上L1、L2，Java程序员是做不到了，离底层太远。应用场景中，最大的性能瓶颈，往往都是数据库，而不是程序。如果问题出在程序，则基本都是程序的Bug，而不是程序没有优化到极致。比如：曾经遇到一个CPU Load逐渐到达几百的场景，而最终的答案，是特殊情况下的线程死循环。 CPU为了提高速度，加了很多Cache，这对我们写好程序也有影响。如果是一个CPU，就不会存在线程安全问题了吗？依然会的，CPU调度的时候，依然可能在3条指令之间中断。 volatile关键字，屏蔽了L1、L2，让变量的结果之间写到内存，写的时候锁总线，所以其他线程读到的一定是最新的结果，实现了读线程安全。参考文章：[聊聊并发（一）——深入分析Volatile的实现原理](http://www.infoq.com/cn/articles/ftf-java-volatile)。 ThreadLocal，这个类在Java语言中，紧紧跟随着线程，存储线程本身的变量，非常像CPU的L1、L2。 既然CPU那么快，为什么CPU还会经常负载报警呢？抛开应用层面的原因不说，从语言角度来说，在操作系统层面上，是有锁的， strace跟一下，发现很多，futex，这是JVM为了保证代码执行的顺序性。虽然我的代码没有加锁，实际是有的。搞c的比java快得多，这也是原因。 # 程序员的天空 编程，就跟写作、绘画、作曲一样，首先是一种创造性的活动，而不是一个技术工作。 当然，对一种技术或编程语言的不断练习和保持熟悉很重要，这其实就是在学习使用工具和技法，但它并不会让你本质上变成一名更优秀的程序员。它只是让你能更熟练的使用工具。 而能让你成为更优秀的程序员的是学会如何思考问题，因为最终你是把脑子里思考出的逻辑转换成了一系列操作计算机的指令，让计算机遵照指令解决问题。 学习如何正确的思考——如何抽象归纳，如何组合，如何分析信息，如何自我反省——可以通过各种方式，远非只有编程一种。 有一本书：《黑客与画家》，可以看一遍。 # 后记 知识支离破碎，单讲起来很多人能知道，如果能串起来，殊为不易，这是一个融会贯通的阶段，悟道的前篇。 深度，和广度是相得益彰的。 深度，是技术层面更需要的；广度是管理层面更需要的。 二者相辅相成，就无敌了。

Java的生产系统，最常用的是Linux，所以当解决生产系统问题时，理解Linux系统，熟练掌握常用命令，对于解决问题，甚至对从更高层次理解Java，都是很有帮助的。 那么，应该怎么学Linux呢？上周五听了一次高手讲座，对于学习的串联、衔接、进阶，都是很有帮助的，所以分享到这里来。 本次讲座，先走马观花串一遍Linux命令，让其可以辅助我们的工作。但是不仅仅是讲几个命令而已，而是希望能看清楚一些操作系统层面上的事，达到理解和境界思想上的提升。 理解是灵魂，串讲是骨架，然后可以自行丰满血肉，这是目的。 本次讲座，特别适合“有一定理解，但是不深刻，或者恰恰处于进阶边缘”这种情况的人，一讲，一串，醍醐灌顶，理解会立刻深了一层。 # 1、strace strace常用来跟踪进程执行时的系统调用和所接收的信号。 strace -T -t -f   java Test >out 2>&1 strace -T -t -f p pid 通过这个工具，我们可以看到当Java程序，或者任何一种程序在Linux系统上运行时，实际上都是被分解成Linux API的。 讲这个命令的目的，是提示我们，可以用一种方式，用一种工具，比如strace，去理解我们的程序的运行。 语言，不论在哪种平台运行，最后都是要分解成操作系统API，分解成CPU指令。这是思维的进阶，或者我们忙于日常应用系统的开发，忘记了曾经的本质。 **参考文章：** [使用strace, ltrace寻找故障原因的线索](http://blog.csdn.net/delphiwcdj/article/details/7387325) [五种利用strace查故障的简单方法](http://blog.csdn.net/dlmu2001/article/details/8842891) # 2、进程 pstree 是Linux的进程体系。 ps 是系统某个时刻的进程切面，代表某个时刻有多少个进程在运行。 因为在Linux下，包括进程、Socket等，都是以文件的形式存在的，内存中的。我们可以通过ps找出进程id，然后通过“运行时文件系统”，查看进程的任何信息。 从操作系统层面鉴定进程的信息（路径、jar、连接等），是完全准确的，比从配置文件里面查询准确，也不需要问别人。 ps -ef | grep catalina cd /proc/60282/fd  可以进一步查看更多内容，比如： a、写多少日志：ll | grep log b、启动要那些jar：ll | grep jar c、看到那些一闪一闪的了吗？那些是socket，代表谁连我了：ll | grep socket d、对于这些socket句柄，我们可以进一步查看是什么进程：lsof | grep 387084 # 3、内存+CPU top，这是应该极熟的Linux命令，是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，其显示的内容，和Windows的任务管理器是一样的。 free ，查看内存使用情况。 我们也可以在Windows下使用jvisualvm，以图形化的方式，查看Java应用的内存，线程，也可以把线程dump下来，比如，Test应用运行方式如下： java -Dcom.sun.management.jmxremote.port=9998 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=192.168.80.128 Test 则可以在本地通过jvisualvm监控进程情况，在命令行输入jvisualvm，远程，连接ip地址，之后右键这个远程连接，新建JMX连接，输入端口，则可以监控这个远程java进程了，截图如下：  # 4、网络 netstat -anop | grep LIST   可以查看，都启动了那些端口，比如：  第六列“2489/mongod”，进程号2489，是mongod进程，在27017端口监听mongo接入。 有的时候，netstat不显示PID和应用，这一般是两个原因：权限不够，或者netstat版本太低，小于1.6，如果是版本太低，可以用：lsof -i:端口号，来找出PID。 参考文章：[netstat不显示进程名pid的bug](http://blog.chinaunix.net/uid-28337979-id-4230505.html)。 netstat -anop | grep EST    可以查看，端口都被谁连着呢，比如：  第4列，代表自己的IP和端口；第5列，对标对方的IP和端口；第6列，代表进程号和启动进程的应用。 **其他常用的：** strace -T -t -e network,poll curl www.baidu.com   我们可以看到从我们的机器，到百度的服务器，经过的路由路径 cat /etc/resolv.conf  可以看到域名解析服务器的顺序 cat /etc/hosts  The static table lookup for host name(主机名查询静态表) # 5、线程 top -p 59851  shift+H，查看59851进程，有多少个线程。  第一列PID，线程ID，换算成16进制，就是线程栈中的NID。 我们可以使用 jstack -l 59851查看，整个进程的信息，也可以使用jstack -l 59851 | grep NID，只看一个线程栈的信息。 很多时候，查看问题的时候，都需要找出占用资源最多的线程，然后查看这个线程的线程栈信息。 这几个步骤，操作起来很容易，其实最最关键的是，线程栈dump下来了，要看得懂。 关于JVM线程的讲解，有一些非常好的文章，如下： [JVM 内部运行线程介绍](http://ifeve.com/jvm-thread/) [JVM合集](http://ifeve.com/category/jvm/) # 6、GC Linux下一个进程里面的线程，都是共享内存的，所以当分析内存时 ，要看进程。 jstat -gccause  59851 1000     jstat，即JVM Statistics Monitoring Tool，用于收集HotSpot虚拟机各方面的运行数据  我们不怕YGC，YGC很频繁，很快，系统耗时极短，微妙级，对于用户来说是没有感觉的； 但是FGC要注意，FGC进行的时候，JVM是假死的，只进行FullGC，不处理其他请求，可能会持续几秒，FGC太多，说明YGC回收不了，太多的对象进入老年代，很快占满，系统肯定有问题的。 java -XX:+PrintFlagsInitial ，可以查看JVM的参数配置情况，比如，默认情况下，我们可以看到，Survior：Eden  = 1：8，New：Old  = 2：1。 jmap -histo 59851 | more  Memory Map for Java，生成虚拟机的内存转储快照（heapdump文件）  通过jmap，可以找出系统中可能有安全隐患（比如太多而不能回收）的对象。 通过这些手段，不用分析代码，不用停机，就可以找出问题，解决问题。 jps、jstat、jstack、jmap，这些不是Linux命令，而是JDK写好的放在rt.jar里面的用于辅助诊断的Java APP。 GC是Java程序员的基本功，应该理解的很清晰。 # 7、dstat和iftop 场景1：演示通过sftp上传文件 可以在top中看到sshd和sftp耗费CPU资源很大，因为sftp是基于sshd的；可以在dstat中看到，receive流量很大。 场景2：演示http请求百度首页，通过ss5代理压测，在ss5机器中，dstat显示的send和recv几乎一样。 和我们通常理解的，应该会有很少的发出数据，和很多的接收数据不一致。原因是： 这种理解不对的，作为ss5代理的机器，既从远端接收到大量数据，同时把接收到的大量数据，转发给它所代理的机器，所以有这个网络现象。 这个时候，我们通过iftop，则可以清楚的看到IP到IP的发出发入数据包。 所以，知道，借助于工具，基于Linux的知识，基于Java的知识，定位问题，找出问题，是很关键的。 iftop 是第三方的，是一个实时流量监控工具： 主要用来显示本机网络流量情况及各机器相互通信的流量集合，如单独同那台机器间的流量大小，非常适合于代理服务器和iptables服务器使用。 官方网站：http://www.ex-parrot.com/~pdw/iftop/。 **安装步骤：** yum -y install flex byacc  libpcap ncurses ncurses-devel libpcap-devel wget http://soft.kwx.gd/tools/iftop-0.17.tar.gz #获得软件包 tar zxvf iftop-0.17.tar.gz                      #解压 cd iftop-0.17                                  #进入目录 ./configure                                    #使用默认配置 make && make install                            #编译并安装 如果libpcap包装不上的话，需要到http://pkgs.org/自行下载rpm进行安装。 dstat是Linux自带的，可以yum安装。 **dstat截图：**  **iftop截图：**  # 8、“|”  管道。连接、过滤，这是管道的作用，就像连接千家万户的自来水管 管道操作符，按行给数据，一行一给，把上个命令的输出，变成下个命令的输入。 经常使用的参数-c ，类似于 SQL中的group by。 在linux中，要把日志文件，当成数据库表，日志文件也是有行有列的。日志要标准，要有规律，就会很方便的分割查找。 我们可以借助less、more、cat、sort、uniq、grep、awk等命令，很方便的分析日志。 另外，awk是一个强大的文本分析工具，awk在对数据分析并生成报告时，很强大。简单来说awk就是把文件逐行的读入，以空格为默认分隔符将每行切片，切开的部分再进行各种分析处理。 # 9、其他常用命令 df -h  显示磁盘分区使用情况 du -sh /root/temp  显示某个文件夹的大小     find /root/temp -type f -name "*.txt" | xargs grep "main"  在/root/temp目录下，在普通文件中，在扩展名为txt的文件中，查找含有main字符串的行 lsof -l 显示所有的socket句柄 lsof | grep deleted  刚刚rm或者echo冲文件内容后，看看空间有没有释放 sed 文件内容查找和替换 vim 文本编辑器，常用就会熟悉。开始的时候记录最常用的，比如，翻屏：CTRL+U（D），2gg，3dd，3dw，yy，/查找，?查找。 # 10、学会分析错误的思路 学会错误的模拟重现，会模拟重现就能解决。模拟重现的手段：可以开发一些质量差的代码，把错误做出来。 工具只是帮助我们定位问题的，帮我们记录发生问题时的操作系统切面，要理解这个切面所代表的意义、所隐含的异常，还需要对相关基础知识的深刻了解。比如： - 用jstat看GC，需要对Java的内存管理、垃圾收集技术深入了解； - 用netstat看网络，需要对网络知识，特别是TCP，有深入了解； - 用jstack转储线程栈，需要对Java线程的知识，有深入了解。

XML和JSON是两种常用的数据交换格式。虽然对于XML和JSON的各种操作，仅仅是常用的工具jar包的使用，没有什么技术含量，但鉴于这两种数据格式的普遍使用，还是拿出一点时间，进行一下简单总结。 # XML XML官网：[http://www.xml.com/](http://www.xml.com/) XML保留字符有5个：&、>、<、'、""。 对于XML的解析方式，有两种：DOM方式和SAX方式。DOM是读入内存之后进行各种操作，SAX是流式操作、一次性的。其他的一些工具jar包，比如JDOM、DOM4J，都是对于这两种方式的高层次封装。 **参考网址：** [http://wenku.baidu.com/link?url=7VjI_4xMpWdV2O82WrNI2KO2UNuhefJYeGYe17QUmH89Nlc9NH20oVr8ZMJ2w1RSvphm5UE88L4FhB4fJgCcV4HldRlJsP9n_o1n1r7gunG](http://wenku.baidu.com/link?url=7VjI_4xMpWdV2O82WrNI2KO2UNuhefJYeGYe17QUmH89Nlc9NH20oVr8ZMJ2w1RSvphm5UE88L4FhB4fJgCcV4HldRlJsP9n_o1n1r7gunG) [http://inotgaoshou.iteye.com/blog/1012188](http://inotgaoshou.iteye.com/blog/1012188) **DOM图示：**  **SAX图示：**  **演示代码：** ~~~ import java.io.File; import java.util.Stack; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.w3c.dom.Attr; import org.w3c.dom.Comment; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; /** * 演示两种XML的解析方式：DOM和SAX * * 至于JDOM和DOM4J，只是在这两种方式之上的更高层次的封装 * */ public class XmlDemo { public static void main(String[] args) throws Exception { XmlDemo xmlDemo = new XmlDemo(); // DOM方式 DomDemo domDemo = xmlDemo.new DomDemo("src/main/java/com/cl/roadshow/java/xml/people.xml"); domDemo.iterateByName("PERSON"); domDemo.recursiveElement(); // SAX方式 SaxDemo saxDemo = xmlDemo.new SaxDemo("src/main/java/com/cl/roadshow/java/xml/people.xml"); saxDemo.showEvents(); saxDemo.parseDocument(); } /** * DOM方式解析XML * */ class DomDemo { private String path; public DomDemo(String path) { this.path = path; } /** * 查询所有符合给到名称的Node，大小写敏感 * * @param tagName * @throws Exception */ public void iterateByName(String tagName) throws Exception { // 获得DOM解析器工厂 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); // 获得具体的DOM解析器 DocumentBuilder db = dbf.newDocumentBuilder(); // 解析XML文档，获得Document对象（根结点） Document doc = db.parse(new File(path)); NodeList nodeList = doc.getElementsByTagName(tagName); for (int i = 0; i < nodeList.getLength(); i++) { Element element = (Element) nodeList.item(i); String content = element.getElementsByTagName("NAME").item(0).getFirstChild().getNodeValue(); System.out.println("name:" + content); content = element.getElementsByTagName("ADDRESS").item(0).getFirstChild().getNodeValue(); System.out.println("address:" + content); content = element.getElementsByTagName("TEL").item(0).getFirstChild().getNodeValue(); System.out.println("tel:" + content); content = element.getElementsByTagName("FAX").item(0).getFirstChild().getNodeValue(); System.out.println("fax:" + content); content = element.getElementsByTagName("EMAIL").item(0).getFirstChild().getNodeValue(); System.out.println("email:" + content); System.out.println("--------------------------------------"); } } /** * 从根节点开始，遍历XML的所有元素 * * @throws Exception */ public void recursiveElement() throws Exception { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.parse(new File(path)); // 获得根元素结点 Element root = doc.getDocumentElement(); parseElement(root); } /** * 递归方法 * * @param element */ private void parseElement(Element element) { String tagName = element.getNodeName(); NodeList children = element.getChildNodes(); System.out.print("<" + tagName); // element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断 NamedNodeMap map = element.getAttributes(); // 如果该元素存在属性 if (null != map) { for (int i = 0; i < map.getLength(); i++) { // 获得该元素的每一个属性 Attr attr = (Attr) map.item(i); String attrName = attr.getName(); String attrValue = attr.getValue(); System.out.print(" " + attrName + "=\"" + attrValue + "\""); } } System.out.print(">"); for (int i = 0; i < children.getLength(); i++) { Node node = children.item(i); // 获得结点的类型 short nodeType = node.getNodeType(); if (nodeType == Node.ELEMENT_NODE) { // 是元素，继续递归 parseElement((Element) node); } else if (nodeType == Node.TEXT_NODE) { // 递归出口 System.out.print(node.getNodeValue()); } else if (nodeType == Node.COMMENT_NODE) { System.out.print(""); } } System.out.print(""); } } /** * SAX方式解析XML * */ class SaxDemo { private String path; public SaxDemo(String path) { this.path = path; } public void showEvents() throws Exception { // 获得SAX解析器工厂实例 SAXParserFactory factory = SAXParserFactory.newInstance(); // 获得SAX解析器实例 SAXParser parser = factory.newSAXParser(); // 开始进行解析 parser.parse(new File(path), new EventHandler()); } public void parseDocument() throws Exception { // 获得SAX解析器工厂实例 SAXParserFactory factory = SAXParserFactory.newInstance(); // 获得SAX解析器实例 SAXParser parser = factory.newSAXParser(); // 开始进行解析 parser.parse(new File(path), new ParseHandler()); } /** * 演示SAX解析方式的事件驱动过程 * */ class EventHandler extends DefaultHandler { @Override public void startDocument() throws SAXException { System.out.println("\n--------------------------------------"); System.out.println("start document"); } @Override public void endDocument() throws SAXException { System.out.println("finish document"); System.out.println("--------------------------------------"); } @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { System.out.println("start element"); } @Override public void endElement(String uri, String localName, String qName) throws SAXException { System.out.println("finish element"); } } /** * 演示用SAX方式解析PERSON节点的过程 * */ class ParseHandler extends DefaultHandler { private Stack stack = new Stack(); private String name; private String tel; @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { stack.push(qName); for (int i = 0; i < attributes.getLength(); i++) { String attrName = attributes.getQName(i); String attrValue = attributes.getValue(i); System.out.println(attrName + "=" + attrValue); } } @Override public void characters(char[] ch, int start, int length) throws SAXException { String tag = stack.peek(); if ("NAME".equals(tag)) { name = new String(ch, start, length); } else if ("TEL".equals(tag)) { tel = new String(ch, start, length); } } @Override public void endElement(String uri, String localName, String qName) throws SAXException { stack.pop(); // 表示该元素已经解析完毕，需要从栈中弹出 if ("PERSON".equals(qName)) { System.out.println("NAME：" + name); System.out.println("TEL：" + tel); System.out.println(); } } } } } ~~~ # JSON JSON官网：[http://www.json.org/json-zh.html](http://www.json.org/json-zh.html) 对于JSON的解析，各种语言下都有 很多可用客户端，在Java下，fastjson是推荐使用的一种，快、强大、无依赖。 **代码演示：** ~~~ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.TypeReference; /** * fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发 * * * 主要特点：比其它任何基于Java的解析器和生成器更快，包括jackson；强大；零依赖 * */ public class FastjsonDemo { public static void main(String[] args) { // 将JSON和JavaBean对象互相转换 Person person = new Person(1, "张三", null); String jsonString = JSON.toJSONString(person); System.out.println(jsonString); person = JSON.parseObject(jsonString, Person.class); System.out.println(person.getName()); System.out.println("--------------------------------------"); // 将JSON字符串转化成List对象 Person person1 = new Person(1, "fastjson1", 11); Person person2 = new Person(2, "fastjson2", 22); List persons = new ArrayList(); persons.add(person1); persons.add(person2); jsonString = JSON.toJSONString(persons); System.out.println("json字符串:" + jsonString); persons = JSON.parseArray(jsonString, Person.class); System.out.println(persons.toString()); System.out.println("--------------------------------------"); // 将JSON字符串转化成List对象 List list1 = new ArrayList(); list1.add("fastjson1"); list1.add("fastjson2"); list1.add("fastjson3"); jsonString = JSON.toJSONString(list1); System.out.println(jsonString); List list2 = JSON.parseObject(jsonString, new TypeReference>() { }); System.out.println("list2：" + list2.toString()); System.out.println("--------------------------------------"); // JSON>对象 Map map = new HashMap(); map.put("key1", "value1"); map.put("key2", "value2"); Map map2 = new HashMap(); map2.put("key1", 1); map2.put("key2", 2); List> list3 = new ArrayList>(); list3.add(map); list3.add(map2); jsonString = JSON.toJSONString(list3); System.out.println("json字符串:" + jsonString); List> list4 = JSON.parseObject(jsonString, new TypeReference>>() { }); System.out.println("list4：" + list4.toString()); } } class Person { private Integer id; private String name; private Integer age; public Person() { } public Person(Integer id, String name, Integer age) { super(); this.id = id; this.name = name; this.age = age; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("ID:").append(id); sb.append("-Name:").append(name); sb.append("-Age:").append(age); return sb.toString(); } } ~~~

# 概述 通讯，源于网络，网络从下到上，分为7层：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层；通讯，基于协议，常用的协议有很多，比如网络层协议IP、传输层协议TCP/UDP、应用层协议HTTP/SOAP/REST等。 我们还会经常听到Socket，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。有个形象的比喻：HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。 任何语言，都会提供对通讯的支持，我们今天用Java语言，演示几种在Java中比较常用的通讯技术，包括：Socket、Http、REST、Dubbo、Thrift、FTP。 # Socket **SocketServer.java** ~~~ import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class SocketServer { public static void main(String[] args) { SocketServer ss = new SocketServer(); //设定服务端的端口号 ServerSocket s = null; try { s = new ServerSocket(10099); System.out.println("ServerSocket Start:"+s); while(true) { Socket socket = s.accept(); //这个地方是阻塞的 System.out.println("Server_Accept:"+socket); SocketServer.HandleSocket vsm = ss.new HandleSocket(socket); new Thread(vsm).start(); } } catch (IOException e) { e.printStackTrace(); } finally { try { s.close(); } catch (IOException e) { } } } class HandleSocket implements Runnable { private Socket socket; public HandleSocket(Socket socket) { this.socket = socket; } @Override public void run() { BufferedReader br = null; PrintWriter pw = null; try { //用于接收客户端发来的请求 br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //用于发送返回信息,可以不需要装饰这么多io流使用缓冲流时发送数据要注意调用.flush()方法 pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true); String str = br.readLine(); if(str != null) { pw.println("OK_"+Thread.currentThread().getName()); pw.flush(); System.out.println("Command:"+str); } } catch (Exception e) { e.printStackTrace(); }finally{ System.out.println("Server_Close:"+socket); try { br.close(); pw.close(); socket.close(); } catch (Exception e2) { } } } } } ~~~ **SocketClient.java** ~~~ import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.net.Socket; public class SocketClient { public static void main(String[] args) throws InterruptedException { for(int i=0;i<10;i++) { call( "Hello" + i); } } public static void call(String command) { Socket socket = null; BufferedReader br = null; PrintWriter pw = null; try { //客户端socket指定服务器的地址和端口号 socket = new Socket("127.0.0.1", 10099); System.out.println("Client_Open" + socket + " Command:" + command); //同服务器原理一样 br = new BufferedReader(new InputStreamReader(socket.getInputStream())); pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))); pw.println(command); pw.flush(); String str = br.readLine(); System.out.println("Client_Receive:"+str); } catch (Exception e) { e.printStackTrace(); } finally { try { System.out.println("Client_Close："+socket); br.close(); pw.close(); socket.close(); } catch (Exception e) { e.printStackTrace(); } } } } ~~~ # Http ### **HttpConnection演示** ~~~ import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.net.HttpURLConnection; import java.net.URL; public class HttpConnectionTest { public static void main(String[] args) throws Exception { System.out.println("begin send"); String inputParam = "Test"; URL url = null; HttpURLConnection httpConn = null; OutputStream output = null; OutputStreamWriter outr = null; //url = new URL("http://127.0.0.1:8888/iotest/ReadServlet"); url = new URL("http://www.baidu.com"); httpConn = (HttpURLConnection) url.openConnection(); httpConn.setConnectTimeout(30000); httpConn.setReadTimeout(30000); HttpURLConnection.setFollowRedirects(true); httpConn.setDoOutput(true); httpConn.setRequestMethod("POST"); httpConn.setRequestProperty("Content-Type", "text/xml"); httpConn.connect(); output = httpConn.getOutputStream(); outr = new OutputStreamWriter(output); // 写入请求参数 outr.write(inputParam.toString().toCharArray(), 0, inputParam.toString().length()); outr.flush(); outr.close(); System.out.println("send ok"); int code = httpConn.getResponseCode(); System.out.println("code " + code); System.out.println(httpConn.getResponseMessage()); //读取响应内容 String sCurrentLine = ""; String sTotalString = ""; if (code == 200) { java.io.InputStream is = httpConn.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(is)); while ((sCurrentLine = reader.readLine()) != null) if (sCurrentLine.length() > 0) sTotalString = sTotalString + sCurrentLine.trim(); } else { sTotalString = "远程服务器连接失败,错误代码:" + code; } System.out.println("response:" + sTotalString); } } ~~~ ### **Apache HttpComponents** 官网：[http://hc.apache.org/](http://hc.apache.org/) 已经废弃的Jar（这个项目，自从2007年8月份就不再维护了，已经迁移到org.apache.httpcomponents了）： ~~~ commons-httpclient commons-httpclient 3.1 ~~~ org.apache.httpcomponents maven依赖： ~~~ org.apache.httpcomponents httpcore 4.2.3 org.apache.httpcomponents httpclient 4.2.3 ~~~ Apache HttpComponents代码演示： ~~~ import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.security.KeyStore; import java.util.ArrayList; import java.util.List; import org.apache.http.HttpEntity; import org.apache.http.HttpException; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.HttpPost; import org.apache.http.conn.scheme.Scheme; import org.apache.http.conn.ssl.SSLSocketFactory; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicNameValuePair; import org.apache.http.params.CoreConnectionPNames; import org.apache.http.params.HttpParams; import com.creditease.ns.oltp.tunneladapter.tunnels.cb.util.CbConst; /** * 更多参考网址：http://hc.apache.org/ * */ public class HttpClientTest { static String url = "http://www.tuicool.com/"; public static void main(String[] args) throws HttpException, IOException { testHttp2(); } public static void testHttp2() { org.apache.http.client.HttpClient httpClient = null; HttpPost httpPost = null; InputStream in = null; httpClient = new DefaultHttpClient(); httpPost = new HttpPost(url); String resp = ""; try { httpClient = new DefaultHttpClient(); httpPost = new HttpPost(url); if (url.indexOf("https") != -1) { KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); in = new FileInputStream("quick.keystore"); keyStore.load(in, "chinabank".toCharArray()); SSLSocketFactory sslSocketFactory = new SSLSocketFactory(keyStore); Scheme scheme = new Scheme("https", 443, sslSocketFactory); httpClient.getConnectionManager().getSchemeRegistry().register(scheme); } HttpParams httpParams = httpClient.getParams(); httpParams.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000 * 20); httpParams.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 1000 * 40); List reqPair = new ArrayList(); reqPair.add(new BasicNameValuePair("charset", "UTF-8")); reqPair.add(new BasicNameValuePair("req", "nihao")); UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(reqPair, "UTF-8"); httpPost.setEntity(urlEncodedFormEntity); HttpResponse response = httpClient.execute(httpPost); HttpEntity responseEntity = response.getEntity(); if (responseEntity != null) { InputStream is = responseEntity.getContent(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; int ch = 0; while ((ch = is.read(buffer)) != -1) { baos.write(buffer, 0, ch); } byte bytes[] = baos.toByteArray(); resp = new String(bytes, CbConst.ENCODING); } int statusCode = response.getStatusLine().getStatusCode(); System.out.println("statusCode：" + statusCode); System.out.println("resp：" + resp); } catch (Exception e) { e.printStackTrace(); } finally { try { if (in != null) { in.close(); } httpPost.releaseConnection(); httpClient.getConnectionManager().shutdown(); } catch (Exception e) { e.printStackTrace(); } } } } ~~~ quick.keystore，是一个密码保护的文件，存放私钥和证书。可以通过JDK自带的keytool工具生成。只要有密码，可以提取出私钥和证书。参考网址： [从Java Keystore文件中提取私钥、证书](http://blog.csdn.net/moreorless/article/details/4985940)[](#) [keystore提取私钥和证书](http://blog.csdn.net/madun/article/details/8677783) [java 调用 keytool 生成keystore 和 cer 证书](http://blog.csdn.net/saindy5828/article/details/11987587) [KeyStore中的别名](http://blog.csdn.net/peterwanghao/article/details/1771723) ### 一个Http压测例程 ~~~ import java.io.BufferedReader; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.InetSocketAddress; import java.net.Proxy; import java.net.URL; import java.text.SimpleDateFormat; import java.util.Date; import java.util.List; import java.util.Map.Entry; import java.util.Timer; import java.util.TimerTask; import java.util.UUID; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class HttpSocketPressTest { private Long succNum = 0L; private Long failNum = 0L; private Long connFailNum = 0L; private Long readFailNum = 0L; private Long otherFailNum = 0L; private Long beginTime = System.currentTimeMillis(); private Boolean recordSuccReturn = false; private String url = "http://www.baidu.com"; public static final int ThreadNum = 100; public static final int MonitorInterval = 3; public static void main(String[] args) throws Exception { createDir("d:\\httptest\\"); createDir("d:\\httptest\\succ\\"); createDir("d:\\httptest\\fail\\"); createDir("d:\\httptest\\exec\\"); createDir("d:\\httptest\\execother\\"); HttpSocketPressTest hspt = new HttpSocketPressTest(); if ((args != null) && (args.length > 0)) { hspt.setRecordSuccReturn(true); } System.out.println("开" + ThreadNum + "个线程，测试用使用Socket5[10.100.140.85:1080]代理Get方式访问外网。"); System.out.println("如果需要对200返回也记录返回内容，请运行程序时输入任意参数，记录位置d:/httptest/succ。"); System.out.println("异常及非200返回会写在d:/httptest/exception和fail目录。"); ExecutorService executorService = Executors.newFixedThreadPool(ThreadNum); for (int i = 0; i < ThreadNum; i++) { executorService.submit(new HttpConn(hspt)); } Monitor m = new Monitor(hspt); Timer timer = new Timer(); timer.schedule(m, MonitorInterval * 1000, MonitorInterval * 1000); } public synchronized void IncreaseSuccNum() { succNum++; } public synchronized void IncreaseFailNum() { failNum++; } public synchronized void IncreaseConnFailNum() { connFailNum++; } public synchronized void IncreaseReadFailNum() { readFailNum++; } public synchronized void IncreaseOtherFailNum() { otherFailNum++; } public synchronized Long getSuccNum() { return succNum; } public synchronized Long getFailNum() { return failNum; } public synchronized Long getConnFailNum() { return connFailNum; } public synchronized Long getReadFailNum() { return readFailNum; } public synchronized Long getOtherFailNum() { return otherFailNum; } public Long getBeginTime() { return beginTime; } public void setRecordSuccReturn(Boolean b) { recordSuccReturn = b; } public Boolean getRecordSuccReturn() { return recordSuccReturn; } public String getUrl() { return url; } private static void createDir(String dir) { File f = new File(dir); if (!f.exists()) { f.mkdir(); } } } class Monitor extends TimerTask { private HttpSocketPressTest hspt; private Long times = 0L; public Monitor(HttpSocketPressTest hspt) { this.hspt = hspt; } @Override public void run() { Long nowTime = System.currentTimeMillis(); Long interval = nowTime - hspt.getBeginTime(); System.out.println(""); System.out.println("间隔" + HttpSocketPressTest.MonitorInterval + "秒报告一次结果，这是第" + ++times + "次，如下："); System.out.println("当前时间：" + new Date()); System.out.println("累计运行时间（单位秒）：" + (interval / 1000)); System.out.println("成功次数：" + hspt.getSuccNum() + "；平均每秒成功次数：" + ((hspt.getSuccNum() * 1000) / interval)); System.out.println("失败次数：" + hspt.getFailNum() + "【Connection timed out：" + hspt.getConnFailNum() + "，Read timed out：" + hspt.getReadFailNum() + "，其他异常：" + hspt.getOtherFailNum() + "】"); } } class HttpConn implements Runnable { private HttpSocketPressTest hspt; public HttpConn(HttpSocketPressTest hspt) { this.hspt = hspt; } @Override public void run() { while (true) { SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd-HHmmss"); String d = sdf.format(new Date()); // System.out.println("[" + d + "] [" + Thread.currentThread().getName() + // "] [访问外网]"); // long startTime = System.currentTimeMillis(); String strUrl = hspt.getUrl(); String domainName = strUrl.split("\\.")[1]; HttpURLConnection httpConn = null; BufferedReader reader = null; try { URL url = null; url = new URL(strUrl); Proxy p; p = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("10.100.140.85", 1080)); httpConn = (HttpURLConnection) url.openConnection(p); httpConn.setConnectTimeout(30 * 1000); httpConn.setReadTimeout(30 * 1000); HttpURLConnection.setFollowRedirects(true); httpConn.setDoOutput(true); httpConn.setRequestMethod("GET"); httpConn.setRequestProperty("Content-Type", "text/xml"); for (Entry> m : httpConn.getHeaderFields().entrySet()) { // System.out.println(m.getKey() + ":" + m.getValue()); } // 这行代码会报：java.net.ConnectException: Connection timed out: connect httpConn.connect(); int code = httpConn.getResponseCode(); // 读取响应内容 String sCurrentLine = ""; StringBuilder sb = new StringBuilder(); if (code == 200) { hspt.IncreaseSuccNum(); } else { hspt.IncreaseFailNum(); } sb.append("StatusCode:").append(code).append("\n"); sb.append("url:").append(strUrl).append("\n"); InputStream is = httpConn.getInputStream(); reader = new BufferedReader(new InputStreamReader(is)); // 这行代码会报：java.net.SocketTimeoutException: Read timed out while ((sCurrentLine = reader.readLine()) != null) { if (sCurrentLine.length() > 0) { sb.append(sCurrentLine.trim()); } } // System.out.println("接收内容大小:" + sb.toString().length()); if (hspt.getRecordSuccReturn() && (code == 200)) { writeFile("d:\\httptest\\succ\\" + d + "_" + UUID.randomUUID() + ".html", sb.toString()); } if (code != 200) { writeFile("d:\\httptest\\fail\\" + d + "_" + UUID.randomUUID() + ".html", sb.toString()); } } catch (Exception e) { e.printStackTrace(); System.out.println(new Date()); hspt.IncreaseFailNum(); String msg = e.toString(); Boolean isOther = false; if (msg.indexOf("Connection timed out") != -1) { hspt.IncreaseConnFailNum(); } else if (msg.indexOf("Read timed out") != -1) { hspt.IncreaseReadFailNum(); } else { isOther = true; hspt.IncreaseOtherFailNum(); } if (isOther) { writeFile("d:\\httptest\\execother\\" + domainName + "_" + d + "_" + UUID.randomUUID() + ".txt", strUrl + "\r\n" + e); } else { writeFile("d:\\httptest\\exec\\" + domainName + "_" + d + "_" + UUID.randomUUID() + ".txt", strUrl + "\r\n" + e); } } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (httpConn != null) { httpConn.disconnect(); } // System.out.println("[" + d + "] [" + Thread.currentThread().getName() // + "] [访问外网] [cost:[" // + (System.currentTimeMillis() - startTime) + "ms]]"); } } } private void writeFile(String name, String content) { FileWriter writer = null; try { // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件 writer = new FileWriter(name, false); writer.write(content); writer.close(); } catch (IOException e) { e.printStackTrace(); } finally { if (writer != null) { try { writer.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } } ~~~ # Dubbo ...待续 # Thrift ...待续 # Rest ...待续 # FTP ...待续

# 题记 JDK，Java Development Kit。 我们必须先认识到，JDK只是，仅仅是一套Java基础类库而已，是Sun公司开发的基础类库，仅此而已，JDK本身和我们自行书写总结的类库，从技术含量来说，还是在一个层级上，它们都是需要被编译成字节码，在JRE中运行的，JDK编译后的结果就是jre/lib下的rt.jar，我们学习使用它的目的是加深对Java的理解，提高我们的Java编码水平。 本系列所有文章基于的JDK版本都是1.7.16。 源码下载地址：[https://jdk7.java.net/source.html](https://jdk7.java.net/source.html) # 本节内容 Java IO库提供了一个可以称之为链接的机制，可以将一个流与另一个流首尾衔接，形成一个流管道的链接。这种机制实际上是装饰模式（Decorator）的应用。 通过流的链接，可以动态的增加流的功能，而这种功能的增加，是通过动态的组合一些流的基本功能获取的。 我们要获取一个IO对象，往往要产生多个IO对象，这也是Java IO库不太容易掌握的地方，但这种在IO库中Decorator模式的运用，给我们提供了实现上的灵活性。 # 流的分类 节点流：从特定的地方读写的流类，比如磁盘或内存；比如FileInputStream/FileOutputStream就是节点流。 过滤流：使用节点流作为输入输出，提供功能的增强，继承自FilterInputStream/FilterOututStream的类（比如DataInputStream提供读写Java基本数据类型的能力，BufferedInputStream提供数据缓存的能力）。 管道流：用于线程间的通信，比如PipedInputStream/PipedOutputStream。 演示一个功能增强的流程： File  --》FileInputStream（从文件中读取字节） --》 BufferedInputStream（增加了缓冲功能）--》DataInputStream（增加了读取Java基本数据类型的能力）--》数据 数据 --》DataInputStream（输出流写入Java基本类型）--》BufferedOutputStream（提供数据写入缓冲区的功能）--》FileOutputStream（写入文件）--》File 字节流和字符流： Java语言使用Unicode来表示字符。 Reader和Writer主要用来读写字符。 # 对象序列化 将对象转化为字节流保存起来，并在日后还原这个对象，这种机制叫做对象序列化。 将一个对象保存到永久存储设备上，叫做持久化。 一个对象要想能够实现序列化，必须实现java.io.Serializable接口，这个接口是一个声明式接口，没有任何内容，只是告诉编译器，对象是可以序列化的。 当一个对象被序列化时，只保留这个对象的非静态成员变量，不能保存任何成员方法和静态的成员变量。 如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。 如果一个可序列化的对象包含对某个不可序列化的对象的成员变量的引用，那么整个序列化操作会失败，并且抛出一个异常：java.io.NotSerializableException。我们可以将这个引用标记为transient，那么这个对象也可以序列化。因为用transient关键字标记的变量，在序列化时，会被抛弃。 ### serialVersionUID Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。 （1）实现了Serializable接口的对象，可以显示设置serialVersionUID的值（JDK源码中就是这么干的） （2）也可以不设置serialVersionUID的值，这时，Java序列化机制会根据编译的class（它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的）自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果class文件（类名、方法等）没有发生变化，增加空格、换行、注释是可以的，编译多次，serialVersionUID也不会变化的；如果增加了方法、变量等，则会报异常：java.io.InvalidClassException （3）日常生产中，我们经常这么设置：private static final long serialVersionUID = 1L; 这时，Java序列化机制会认为版本是一致的，只会对能对照起来的变量进行赋值，对于类和序列化的数据中不一致的地方（比如序列化之后，类增加减少了字段），会直接抛弃 ### 对象序列化代码演示 ~~~ import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.net.URI; import java.net.URISyntaxException; public class Test { public static void main(String[] args) throws Exception { serial(); Person p = deserial(); System.out.println(p.getName()); System.out.println(p.getAge()); } private static void serial() throws Exception { Person p = new Person("zhangsan",18); FileOutputStream fos = new FileOutputStream("/Users/puma/tt/person.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(p); oos.flush(); oos.close(); } private static Person deserial() throws Exception{ FileInputStream fis = new FileInputStream("/Users/puma/tt/person.txt"); ObjectInputStream ois = new ObjectInputStream(fis); Person p = (Person)ois.readObject(); return p; } } class Parent implements Serializable {} class Person extends Parent { private static final long serialVersionUID = 1L; private String name; private Integer age; public Person(String name,Integer age) { this.setName(name); this.setAge(age); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } } ~~~ # NIO Java Non-blocking IO，很多著名的异步通信框架，比如Netty/Mina，都是基于NIO的，对性能大有提升。 异步 I/O 的一个优势在于，它允许您同时根据大量的输入和输出执行 I/O。同步程序常常要求助于轮询，或者创建许许多多的线程以处理大量的连接。 使用异步 I/O，您可以监听任何数量的通道上的事件，不用轮询，也不用额外的线程。 临时还没来得及仔细钻研，记录几篇文章： [http://blog.csdn.net/kobejayandy/article/details/11545057](http://blog.csdn.net/kobejayandy/article/details/11545057) [http://news.cnblogs.com/n/205413/](http://news.cnblogs.com/n/205413/) [http://weixiaolu.iteye.com/blog/1479656](http://weixiaolu.iteye.com/blog/1479656) [http://www.iteye.com/topic/834447](http://www.iteye.com/topic/834447) [http://blog.csdn.net/anders_zhuo/article/details/8535719](http://blog.csdn.net/anders_zhuo/article/details/8535719)

# 题记 JDK，Java Development Kit。 我们必须先认识到，JDK只是，仅仅是一套Java基础类库而已，是Sun公司开发的基础类库，仅此而已，JDK本身和我们自行书写总结的类库，从技术含量来说，还是在一个层级上，它们都是需要被编译成字节码，在JRE中运行的，JDK编译后的结果就是jre/lib下的rt.jar，我们学习使用它的目的是加深对Java的理解，提高我们的Java编码水平。 本系列所有文章基于的JDK版本都是1.7.16。 源码下载地址：[https://jdk7.java.net/source.html](https://jdk7.java.net/source.html) # 本节内容 在本节中，简析java.util包所包含的工具类库，主要是集合相关的类库，其次还有正则、压缩解压、并发、日期时间等工具类。 本篇内容大致、简单的对于java.util包进行了一个描述，以后会逐渐进行内容补充，本篇文章相当于一个占位符，所谓先有了骨架，才能逐渐丰满 # 集合类 ### 基本情况 **主要接口及其继承关系如下：** SortedSet  -->  Set --> Collection -->  Iterable List  -->  Collection  -->  Iterable SortedMap  -->  Map **常用类及其继承关系如下：** HashSet/LinkedHashSet  --> Set TreeSet  -->  SortedSet  --> Set ArrayList/LinkedList  -->  List HashMap  -->  Map TreeMap  -->  SortedMap  -->  Map 统一称谓：Collection分支的，我们称之为“聚集”；Map分支的，我们称之为“映射”。 Collection继承自Iterable，所以其下的类都可以用迭代器Iterator访问，也可以用for(E e:es)形式访问；Map可以用实现了其内部接口Entry的对象，作为一个元素。 Hashtable和HashMap，他们都实现了Map接口；Hashtable继承自古老的抽象类Dictionary，是线程安全的；HashMap继承自较新的抽象类AbstractMap，不是线程安全的。 HashMap允许null的键和值，而Hashtable不允许null的键和值，这是因为： Hashtable有方法contains方法（判断是否存在值），如果允许的话，则不论key或者value为null，都会返回null，这容易误解，所以Hashtable就强制限制了，对于null 键和值，直接抛出NullPointerException； HashMap没有contains方法，分别是containsKey()和containsValues()。 另外JDK5开始，对于线程安全的Map，有一种ConcurrentHashMap，高效，其实现线程安全的过程中，没有使用synchronized，是一种分段的结构，并用CAS这种无锁算法实现了线程安全。 ### Hash Object类有两种方法来推断对象的标识：equals()和hashCode()。 一般来说，如果您忽略了其中一种，您必须同时忽略这两种，因为两者之间有必须维持的至关重要的关系。 特殊情况是根据equals() 方法，如果两个对象是相等的，它们必须有相同的hashCode()值，Object源码中对此有要求，尽管这通常不是真的。 [http://blog.sina.com.cn/s/blog_5dc351100101l57b.html](http://blog.sina.com.cn/s/blog_5dc351100101l57b.html) [http://fhuan123.iteye.com/blog/1452275](http://fhuan123.iteye.com/blog/1452275) 关于HashMap的源码分析，可以参考：[http://github.thinkingbar.com/hashmap-analysis/](http://github.thinkingbar.com/hashmap-analysis/) LinkedHashMap，重写了HashMap的迭代器、AddEntry、Entry等几个方法和类，用一个双向链表存储元素加入的顺序；这可以按照访问顺序排序，最近访问的元素（get/put），会被放在链表的末尾，这是LRU算法（Least Recenty Used），最近最少使用算法。 ### ArrayList和LinkedList 关于ArrayList和LinkedList，ArrayList是基于数组的，这种方式将对象放在连续的位置中，读取快，但是容量不足时需要进行数组扩容，性能降低，插入和删除也慢；LinkedList是基于链表的，插入和删除都快，但是查找麻烦，不能按照索引查找。所以说，对于构造一个队列是用ArrayList或者LinkedList，是根据性能和方便来考虑的，比如LinkedList有removeLast()，ArrayList只能remove(index)，用LinkedList构造一个Queue的代码演示如下： ~~~ class Queue { private LinkedList llt; public Queue() { llt = new LinkedList(); } public void add(String s) { llt.add(s); } public String get() { return llt.removeLast(); //队列 //return llt.removeFirst(); //堆栈 } public boolean isNull() { return llt.isEmpty(); } } ~~~ ### ConcurrentModificationException ~~~ import java.util.*; import java.util.Map.Entry; class Test { public static void main(String[] args) throws Exception { HashMap mTemp = new HashMap(); mTemp.put("test1",1); Iterator> iTemp = mTemp.entrySet().iterator(); //以下这行代码会引发java.util.ConcurrentModificationException， //因为对聚集创建迭代器之后，进行遍历或者修改操作时，如果遇到期望的修改计数器和实际的修改计数器不一样的情况（modCount != expectedModCount） //就会报这个Exception，乐观锁的思想 //mTemp.put("test2",2); while(iTemp.hasNext()) { System.out.println(iTemp.next().getKey()); } //for循环,写法更简单一些，在编译后，还是会被转换为迭代器 for(Entry e : mTemp.entrySet()) { System.out.println(e.getKey()); } ArrayList al = new ArrayList(); al.add("test"); for(String s : al) { Integer i = Integer.reverse((new java.util.Random().nextInt(100))); al.add(i.toString()); //这行代码也会报ConcurrentModificationException } } } ~~~ 对于这种情况，可以使用java.util.concurrent包中的相关类，比如CopyOnWriteArrayList，就不会报这个异常了，因为CopyOnWriteArrayList类最大的特点就是，在对其实例进行修改操作（add/remove等）会新建一个数据并修改，修改完毕之后，再将原来的引用指向新的数组。这样，修改过程没有修改原来的数组，也就没有了ConcurrentModificationException错误。 我们可以参考CopyOnWriteArrayList的源码： ~~~ /** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return true (as specified by {@link Collection#add}) */ public boolean add(E e) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] elements = getArray(); int len = elements.length; Object[] newElements = Arrays.copyOf(elements, len + 1); newElements[len] = e; setArray(newElements); return true; } finally { lock.unlock(); } } ~~~ ConcurrentModificationException，表明：我正读取的内容被修改掉了，你是否需要重新遍历？或是做其它处理？这就是fast-fail（快速失败机制）的含义。 虽然这只是在一个线程之内，并不是多线程的，我们同样也可以这样理解fast-fail： Fail-fast是并发中乐观(optimistic)策略的具体应用，它允许线程自由竞争，但在出现冲突的情况下假设你能应对，即你能判断出问题何在，并且给出解决办法； 悲观(pessimistic)策略就正好相反，它总是预先设置足够的限制，通常是采用锁(lock)，来保证程序进行过程中的无错，付出的代价是其它线程的等待开销。 快速失败机制主要目的在于使iterator遍历数组的线程能及时发现其他线程对Map的修改（如put、remove、clear等），因 此，fast-fail并不能保证所有情况下的多线程并发错误，只能保护iterator遍历过程中的iterator.next()与写并发. ### TreeSet和Collections.sort TreeSet是基于TreeMap的实现，底层数据结构是“红黑树”，数据加入时已经排好顺序，存取及查找性能不如HashSet；Collections.sort是先把List转换成数组，再利用“归并排序”算法进行排序，归并排序是一种稳定排序。 关于TreeMap的文章： [http://zh.wikipedia.org/wiki/%E7%BA%A2%E9%BB%91%E6%A0%91](http://zh.wikipedia.org/wiki/%E7%BA%A2%E9%BB%91%E6%A0%91) [http://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html](http://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html) [http://shmilyaw-hotmail-com.iteye.com/blog/1836431](http://shmilyaw-hotmail-com.iteye.com/blog/1836431) [http://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html](http://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html) [http://blog.csdn.net/chenhuajie123/article/details/11951777](http://blog.csdn.net/chenhuajie123/article/details/11951777) 对这两种排序算法的性能比较如下（24核、64G内存，RHEL6.2）： 在数据已经基本排好顺序的情况下，排序元素数目，在某个段内（大约是2万-20万），TreeSet更高效；其他数目下Collections.sort更高效； 在数据随机性较强的情况下，排序元素数目，在1万之内，相差不大，Collections.sort性能略高；在1万之外，80万之内，TreeSet性能明显高于Collections.sort；80万之外，Collection.sort性能更高；java.util.concurrent.ConcurrentSkipListSet这种基于“跳表”的线程安全的可排序类，在30万之内，性能高于Collection.sort，30万之外，性能低于Collection.sort，ConcurrentSkipListSet的排序性能总是低于TreeSet。 ConcurrentSkipListSet有一个平衡的树形索引机构没有的好处，就是在并发环境下其表现很好。 这里可以想象，在没有了解SkipList这种数据结构之前，如果要在并发环境下构造基于排序的索引结构，那么也就红黑树是一种比较好的选择了，但是它的平衡操作要求对整个树形结构的锁定，因此在并发环境下性能和伸缩性并不好。 代码演示如下： ~~~ import java.util.TreeSet; import java.util.ArrayList; import java.util.Comparator; import java.util.Collections; import java.util.Arrays; import java.util.ListIterator; import java.util.Random; import java.util.Iterator; class Test { public static void main(String[] args) { final int LEN = 300000; final int SEED = 100000; Random r = new Random(); System.out.println("---------------------------"); long b = System.currentTimeMillis(); TreeSet ts = new TreeSet(new Comparator(){ public int compare(Temp t1,Temp t2) {return t1.id-t2.id;} }); for(int i=0;i aTemp = new ArrayList(); Iterator it = ts.iterator(); while(it.hasNext()) { aTemp.add(it.next()); } System.out.println(System.currentTimeMillis() - b); System.out.println("---------------------------"); b = System.currentTimeMillis(); ArrayList al = new ArrayList(); for(int i=0;i() { public int compare(Temp t1,Temp t2) {return t1.id-t2.id;} });*/ Temp[] a = new Temp[al.size()]; al.toArray(a); System.out.println(System.currentTimeMillis() - b); Arrays.sort(a,new Comparator() { public int compare(Temp t1,Temp t2) {return t1.id-t2.id;} }); System.out.println(System.currentTimeMillis() - b); ListIterator li = al.listIterator(); for(int i=0;i进行排序比较，性能很差。开始以为JDK对Entry做过优化，static/final之类，后来把对象也改成final，里面元素也改成final，发现性能依旧很差，完全不能解释，感觉无法理解。 后来，发现是两段代码不一致，使用Entry进行排序的代码有bug，导致排序的数据很少，所以显得性能好。。。。 所以，无端的臆测还是不要的，建立在JDK深入理解的基础上就好。 ### 另外一个排序思路 比如，取出Top 20，也不一定要全部排序，可以只取前20个，经验证，小数据量时，性能也是非常高，大数据未验证。代码大致如下： ~~~ int n = 0; double minScore = 100; //Top20中最小的积分 String minKey = ""; //最小值所在的Key Map skuTop = new HashMap(); Set styles = new HashSet(); //过滤同款 for(String sku :tempSkuViewSkus.get(goodsUser.getKey())) { boolean filter = false; filter = filterSameStyle(sku,styles); if(filter) continue; //过滤不成功，直接continue Set userSet = goodsUserView.get(sku); if(userSet == null || userSet.size() == 0) continue; //这一步，积分的计算，是最耗时的操作（性能瓶颈所在） double score = mathTools.getJaccardSimilar(goodsUser.getValue(), userSet); //前20个直接进入Map if(n++ < ConstMongo.maxRecomNum) { skuTop.put(sku, score); if(score < minScore) { minScore = score; minKey = sku; } continue; } if(score <= minScore) continue; //替换最小值 skuTop.remove(minKey); skuTop.put(sku, score); minScore = score; minKey = sku; for(Entry e : skuTop.entrySet()) { if(e.getValue() < minScore) { minScore = e.getValue(); minKey = e.getKey(); } } } ~~~ ### 正则表达式 ~~~ import java.util.regex.Matcher; import java.util.regex.Pattern; public class Hello { public static void main(String[] args) { Pattern pattern = Pattern.compile("正则表达式"); //Pattern pattern = Pattern.compile("Hello,正则表达式\\s[\\S]+"); Matcher matcher = pattern.matcher("正则表达式 Hello,正则表达式 World"); //替换第一个符合正则的数据 System.out.println(matcher.replaceFirst("Java")); } } ~~~ 常用的开发语言都支持正则表达式，但是其对于正则支持的程度是不一样的。 Js正则：[http://msdn.microsoft.com/zh-cn/library/ae5bf541(VS.80).aspx](http://msdn.microsoft.com/zh-cn/library/ae5bf541(VS.80).aspx) Python正则：[http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html](http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html) Java正则： [http://www.blogjava.net/xzclog/archive/2006/09/19/70603.html](http://www.blogjava.net/xzclog/archive/2006/09/19/70603.html) [http://www.cnblogs.com/android-html5/archive/2012/06/02/2533924.html](http://www.cnblogs.com/android-html5/archive/2012/06/02/2533924.html) # 并发相关类 如下章节的内容有简单使用演示：[http://blog.csdn.net/puma_dong/article/details/37597261#t5](http://blog.csdn.net/puma_dong/article/details/37597261#t5) # 压缩解压类 如下章节的内容有简单使用演示：[http://blog.csdn.net/puma_dong/article/details/23018555#t20](http://blog.csdn.net/puma_dong/article/details/23018555#t20) # 其他工具类 定时器、日期、时间、货币等

# 题记 JDK，Java Development Kit。 我们必须先认识到，JDK只是，仅仅是一套Java基础类库而已，是Sun公司开发的基础类库，仅此而已，JDK本身和我们自行书写总结的类库，从技术含量来说，还是在一个层级上，它们都是需要被编译成字节码，在JRE中运行的，JDK编译后的结果就是jre/lib下的rt.jar，我们学习使用它的目的是加深对Java的理解，提高我们的Java编码水平。 本系列所有文章基于的JDK版本都是1.7.16。 源码下载地址：[https://jdk7.java.net/source.html](https://jdk7.java.net/source.html) # 本节内容 在本节中，简析java.lang包所包含的基础类库，当我们新写一个class时，这个package里面的class都是被默认导入的，所以我们不用写import java.lang.Integer这样的代码，我们依然使用Integer这个类，当然，如果你显示写了import java.lang.Integer也没有问题，不过，何必多此一举呢 # Object 默认所有的类都继承自Object，Object没有Property，只有Method，其方法大都是native方法（也就是用其他更高效语言，一般是c实现好了的）， Object没有实现clone()，实现了hashCode()，哈希就是对象实例化后在堆内存的地址，用“==”比较两个对象，实际就是比较的内存地址是否是一个，也就是hashCode()是否相等， 默认情况下，对象的equals()方法和==符号是一样的，都是比较内存地址，但是有些对象重写了equals()方法，比如String，使其达到比较内容是否相同的效果 另外两个方法wait()和notify()是和多线程编程相关的，多线程里面synchronized实际就是加锁，默认是用this当锁，当然也可以用任何对象当锁，wait()上锁，线程阻塞，notify()开锁，收到这个通知的线程运行。以下代码示例： ~~~ class Test implements Runnable { private String name; private Object prev; private Object self; public Test(String name,Object prev,Object self) { this.name=name; this.prev = prev; this.self = self; } @Override public void run() { int count = 2; while(count>0) { synchronized(prev) { synchronized(self) { System.out.println(name+":"+count); count--; self.notify(); //self解锁 } try { prev.wait(); //prev上锁 } catch(InterruptedException e) { e.printStackTrace(); } } } } public static void main(String[] args) throws Exception { Object a = new Object(); Object b = new Object(); Object c = new Object(); Test ta = new Test("A",c,a); Test tb = new Test("B",a,b); Test tc = new Test("C",b,c); new Thread(ta).start(); Thread.sleep(10); new Thread(tb).start(); Thread.sleep(10); new Thread(tc).start(); } } ~~~ 以上代码将顺序输出：A:2、B:2、C:2、A:1、B:1、C:1 。 Object类占用内存大小计算：[http://m.blog.csdn.net/blog/aaa1117a8w5s6d/8254922](http://m.blog.csdn.net/blog/aaa1117a8w5s6d/8254922) Java如何实现Swap功能：[http://segmentfault.com/q/1010000000332606](http://segmentfault.com/q/1010000000332606) # 构造函数和内部类 构造函数不能继承，是默认调用的，如果不显示用super指明的话，默然是调用的父类中没有参数的构造函数。 ~~~ class P { public P() {System.out.println("P");} public P(String name) {System.out.println("P" + name);} } class S extends P { public S(String name) { super("pname"); //不过不指定的话，默认是调用的父类的没有参数的构造函数 System.out.println("name"); } } ~~~ 关于内部类，在应用编程中较少用到，但是JDK源码中大量使用，比如Map.Entry，ConcurrentHashMap，ReentrantLock等，enum本身也会被编译成static final修饰的内部类。 关于内部类的更多内容，可以参阅这篇文章：[http://android.blog.51cto.com/268543/384844/](http://android.blog.51cto.com/268543/384844/) # Class和反射类 Java程序在运行时每个类都会对应一个Class对象，可以从Class对象中得到与类相关的信息，Class对象存储在方法区（又名Non-Heap，永久代），当我们运行Java程序时，如果加载的jar包非常多，大于指定的永久代内存大小时，则会报出PermGen错误，就是Class对象的总计大小，超过永久代内存的缘故。 Class类非常有用，在我们做类型转换时经常用到，比如以前用Thrift框架时，经常需要在Model类型的对象：Thrift对象和Java对象之间进行转换，需要手工书写大量模式化代码，于是，就写了个对象转换的工具，在Thrift对象和Java对象的Property名字一致的情况下，可以使用这个工具直接转换，其中大量使用了Class里面的方法和java.lang.reflect包的内容。 关于Calss类，方法众多，不详述。下面附上这个Thrift工具的代码。 ~~~ import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; /** * Thrift前缀的对象和不含Thrift前缀的对象相互转换. * 参考： * http://blog.csdn.net/it___ladeng/article/details/7026524 * http://www.cnblogs.com/jqyp/archive/2012/03/29/2423112.html * http://www.cnblogs.com/bingoidea/archive/2009/06/21/1507889.html * http://java.ccidnet.com/art/3539/20070924/1222147_1.html * http://blog.csdn.net/justinavril/article/details/2873664 */ public class ThriftUtil { public static final Integer THRIFT_PORT = 9177; /** * Thrift生成的类的实例和项目原来的类的实例相关转换并赋值 * 1.类的属性的名字必须完全相同 * 2.当前支持的类型仅包括：byte,short,int,long,double,String,Date,List * 3.如果有Specified列，则此列为true才赋值，否则，不为NULL就赋值 * @param sourceObject * @param targetClass * @param toThrift:true代表把JavaObject转换成ThriftObject，false代表把ThriftObject转换成JavaObject，ThriftObject中含有Specified列 * @return */ public static Object convert(Object sourceObject,Class targetClass,Boolean toThrift) { if(sourceObject==null) { return null; } //对于简单类型，不进行转换，直接返回 if(sourceObject.getClass().getName().startsWith("java.lang")) { return sourceObject; } Class sourceClass = sourceObject.getClass(); Field[] sourceFields = sourceClass.getDeclaredFields(); Object targetObject = null; try { targetObject = targetClass.newInstance(); } catch (InstantiationException e1) { e1.printStackTrace(); } catch (IllegalAccessException e1) { e1.printStackTrace(); }; if(targetObject==null) { return null; } for(Field sourceField:sourceFields) { try { //转换时过滤掉Thrift框架自动生成的对象 if(sourceField.getType().getName().startsWith("org.apache.thrift") ||sourceField.getName().substring(0,2).equals("__") ||("schemes,metaDataMap,serialVersionUID".indexOf(sourceField.getName())!=-1) ||(sourceField.getName().indexOf("_Fields")!=-1) ||(sourceField.getName().indexOf("Specified")!=-1) ) { continue; } //处理以DotNet敏感字符命名的属性，比如operator String sourceFieldName = sourceField.getName(); if(sourceFieldName.equals("operator")) { sourceFieldName = "_operator"; } else { if(sourceFieldName.equals("_operator")) { sourceFieldName = "operator"; } } //找出目标对象中同名的属性 Field targetField = targetClass.getDeclaredField(sourceFieldName); sourceField.setAccessible(true); targetField.setAccessible(true); String sourceFieldSimpleName = sourceField.getType().getSimpleName().toLowerCase().replace("integer", "int"); String targetFieldSimpleName = targetField.getType().getSimpleName().toLowerCase().replace("integer", "int"); //如果两个对象同名的属性的类型完全一致:Boolean,String,以及5种数字类型：byte,short,int,long,double，以及List if(targetFieldSimpleName.equals(sourceFieldSimpleName)) { //对于简单类型，直接赋值 if("boolean,string,byte,short,int,long,double".indexOf(sourceFieldSimpleName)!=-1) { Object o = sourceField.get(sourceObject); if(o != null) { targetField.set(targetObject, o); //处理Specified列，或者根据Specified列对数值对象赋NULL值 try { if(toThrift) { Field targetSpecifiedField = targetClass.getDeclaredField(sourceFieldName+"Specified"); if(targetSpecifiedField != null) { targetSpecifiedField.setAccessible(true); targetSpecifiedField.set(targetObject, true); } } else { Field sourceSpecifiedField = sourceClass.getDeclaredField(sourceFieldName+"Specified"); if(sourceSpecifiedField != null && "B,S,B,I,L,D".indexOf(targetField.getType().getSimpleName().substring(0,1))!=-1 ) { sourceSpecifiedField.setAccessible(true); if(sourceSpecifiedField.getBoolean(sourceObject)==false) { targetField.set(targetObject, null); } } } } catch (NoSuchFieldException e) { //吃掉NoSuchFieldException，达到效果：如果Specified列不存在，则所有的列都赋值 } } continue; } //对于List if(sourceFieldSimpleName.equals("list")) { @SuppressWarnings("unchecked") List