-Flyぁ梦- » Life in Coding

64位Linux下Java进程堆外内存迷之64M问题

-Flyぁ梦- — Fri, 09 Sep 2016 10:44:42 +0000

起因，监控系统检查到link机器内存耗尽，用top查看，果然有一个java进程占用了近24g内存（包括VIRT和RES），但是启动java进程的参数是java -server -Xmx12g -Xms12g -XX:PermSize=50m，理论上只应该占用12g再多一些，所以问题就在这个进程了。此进程主要处理Socket IO读写，使用的是Java NIO。

http://stackoverflow.com/questions/561245/virtual-memory-usage-from-java-under-linux-too-much-memory-used 这里详细描述了top命令里内存显示的意义。

用jstat -gcutil $pid看，发现堆使用率却很低，甚至都没有怎么出现过Full GC，Young GC也很少，堆内存完全够用。jmap -histo:live $pid命令（注：此命令调用会先调用Full GC一次）也看不出有任何对象占用内存很大的情况。

到这里据同事提醒，怀疑是堆外内存泄露。一般情况下是ByteBuffer.allocateDirect()这个API可以开辟堆外内存空间，但是搜索源代码并没有发现有这个调用。

然后据水寒同学提示，可以通过cat /proc/$pid/maps（也可以通过pmap $pid命令）来查看内存使用。然后就发现了问题：

一大块内存正好是12g，应该就是通过-Xmx设置的内存，无标识符
有一块3.5g的内存，最后一列标识符是[heap]
有111块正好为64M或者非常接近64M的内存块，无标识符

显然问题出在这111 * 64m = 6g这里，搜索源代码并没有发现有常量64的使用，一般代码也不会硬coding这么大一块内存呀。如果问题出在引用的某个第三方jar包就难定位问题了。

因为觉得这个64M内存块具有非常显著的特点，于是就通过Google和百度，找到如下：

http://blog.2baxb.me/archives/918

https://www.ibm.com/developerworks/community/blogs/kevgrig/entry/linux_glibc_2_10_rhel_6_malloc_may_show_excessive_virtual_memory_usage

http://it.taocms.org/01/6808.htm

https://infobright.com/blog/malloc_arena_max/

这几篇文章，尤其是ibm那篇文章讲的最细致，Linux glibc >= 2.10 (RHEL 6) malloc may show excessive virtual memory usage。

大致意思是，这个版本的glibc控制的malloc函数，会在64位的Linux的中，给每一个CPU核开辟8个64M内存的缓冲区，用于提高性能。

然后这个问题也被Hadoop官方发现并指出，然后推荐控制环境变量MALLOC_ARENA_MAX=4来达到最优设置。

修改方法：启动java进程脚本前面加入，export MALLOC_ARENA_MAX=4

看看 linux , 内存 , 内存泄露

看看 Java

2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析

jabber和XMPP简述原理

-Flyぁ梦- — Fri, 09 Sep 2016 10:43:45 +0000

为了实现不同IM（即时通讯软件，比如QQ、GTalk）之间可以互相通信，jabber和XMPP为此而生。jabber是Linux中的一个程序，设计了一套开源的协议，用于连接不通的IM，然后XMPP以jabber协议为基础并扩展之。每一个IM程序服务端与客户端之间肯定有一套保密并加密的协议，这个是不可能容易让外部获知的，不然IM软件聊天内容就泄露了，谁还敢用。XMPP是让不同的IM之间互相通信，跟IM程序本身毫无关系。

简单的说就是，QQ在自身服务器外，再搭建一个jabber服务器，GTalk也同理，分别称之为jabberQ和jabberG。QQ用户的标识以@qq.com即为，GTalk用户的标识以@gmail.com结尾。首先QQ用户想要与GTalk用户通信，QQ服务器发现这个请求要发给外部用户而非内部QQ用户，将请求转到jabberQ服务器，jabberQ服务器识别到此外部用户以@gmail.com结尾，需要知道jabberG服务器的IP地址是多少，通过DNS协议去查询gmail.com，其中的SRV Records有一项_xmpp-server._tcp.domain可以获知到对应的jabber服务器域名。

可以通过以下命令手动查询：

dig SRV _xmpp-server._tcp.gmail.com

;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42765
;; flags: qr rd ra; QUERY: 1, ANSWER: 5, AUTHORITY: 4, ADDITIONAL: 4

;; QUESTION SECTION:
;_xmpp-server._tcp.gmail.com. IN SRV

;; ANSWER SECTION:
_xmpp-server._tcp.gmail.com. 900 IN SRV 20 0 5269 alt1.xmpp-server.l.google.com.
_xmpp-server._tcp.gmail.com. 900 IN SRV 20 0 5269 alt2.xmpp-server.l.google.com.
_xmpp-server._tcp.gmail.com. 900 IN SRV 20 0 5269 alt3.xmpp-server.l.google.com.
_xmpp-server._tcp.gmail.com. 900 IN SRV 20 0 5269 alt4.xmpp-server.l.google.com.
_xmpp-server._tcp.gmail.com. 900 IN SRV 5 0 5269 xmpp-server.l.google.com.

具体详见：http://wiki.xmpp.org/web/SRV_Records#XMPP_SRV_records

然后jabberQ服务器，就通过域名alt1.xmpp-server.l.google.com获取到IP地址去与jabberG服务器建立Socket连接了，当然通过XMPP协议规定的xml内容交互，所以jabberQ服务器会将QQ服务器内部的请求转化为开源的XMPP请求。经过jabberG服务器确认后，连接建立，之后的XMPP协议就可以欢快的走起来了，包括加好友、好友上线/下线状态通知、发消息等。jabberG服务器获取到来自jabberQ的XMPP通知后，将此XMPP请求转化为GTalk内部的数据请求转发给GTalk服务器，然后推送到GTalk客户端。

简单地说就这样子，QQ客户端到GTalk客户端的一次数据请求就完成了。

随便看一看

看看 Life in Coding

2015-01-07 -- 防止数据库数据重复的几种方法
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-09-10 -- 记C#和Excel开发
2011-06-11 -- 2011-6-9 Google Doodle之电子琴
2011-03-10 -- 学计算机的尼玛伤不起啊！！！！！！

Linux MySQL查询默认情况下不区分大小写

-Flyぁ梦- — Tue, 30 Aug 2016 12:50:53 +0000

如题，在like搜索中不区分大小写是OK的，但是用=匹配也不区分感觉就有点怪了，具体看项目看需求。此次碰到从数据库中读数据读到了大小写数据，但是代码中却是区分大小写又拦截掉了，导致数据的不一致情况出现。

这样子的SQL写法可以区分大小写

mysql> select * from t1 where name = binary 'YOU';

如果不想这么麻烦而想服务一开启就让大小写一致的话，需要修改配置文件my.ini或者my.cnf
[mysqld]
lower_case_table_names=1（0：区分；1：不区分）

mysql> show variables like ‘%case_table%';
+————————+——-+
| Variable_name | Value |
+————————+——-+
| lower_case_table_names | 1 |
+————————+——-+

随便看一看

2011-10-20 -- ZOJ起步 100AC
2012-01-10 -- 尼康S3000 镜头维修
2013-06-17 -- 徽杭古道
2017-05-03 -- 五一桂林阳朔游
2012-05-15 -- Play框架的Router机制和jregex包

读java concurrency in practice

-Flyぁ梦- — Thu, 18 Aug 2016 07:15:05 +0000

这是一本好书（Java源码作者Doug Lea是作者之一），关于Java并发的各个方面，介绍的很深入，应该算是进阶一类，很多地方不好理解。一开始打算阅读英文版，倒不是英文看不懂，不过还是有很多内容的确理解起来很费劲，尤其是老外写书的风格（废话特别多 = = 一页密密麻麻的英文，让人找不到关键点在哪儿），看几页就没兴趣再看下去哎…后有幸找到了中文翻译版，而且翻译的很有水准，拜谢翻译工作者韩锴和方妙。

找不到翻译版的同学，可以私信我提供。

可以说，自己对Java真正的并发同步的理解还处于入门阶段，看了一遍书很多地方估计还是没有get到的，不过已经学到不少了。这本书值得以后再细细研读。

可重入的概念、可重入锁和java.util.concurrent.locks.ReentrantLock。

详见：可重入锁、ReentrantLock、AQS、Condition

基于AQS的各种同步工具类

有ReentrantLock、ReentrantReadWriteLock、CountDownLatch、Semaphore、FutureTask、CyclicBarrier等

详见：ReentrantReadWriteLock简单分析 CountDownLatch简单分析 Semaphore简单分析 FutureTask简单分析和用法

reordering重排序、happened-before关系、volatile真正语义
基于硬件的原子CAS算法
内置synchronized锁、基于CAS算法的锁、CAS原子类、volatile修饰的性能相关
org.apache.http.annotation包下有一些有用的Annotation，比如ThreadSafe、NotThreadSafe等

看看同步 , 并发 , 锁

2016-06-16 -- ReentrantReadWriteLock简单分析
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition
2015-01-07 -- 防止数据库数据重复的几种方法
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析

看看 Java , Life in reading

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析

线程清理

-Flyぁ梦- — Fri, 05 Aug 2016 09:26:53 +0000

执行脚本遇到一个情况，脚本无法自动退出完毕，必须手动执行Ctrl-C才能退出，之前遇到过这个问题是因为数据库连接没有被正确关闭导致，这次的原因是一个另起的线程没有正常停止的原因。

此线程A维护一个队列，线程A负责从队列中消费，主线程负责往线程中添加，队列池用的LinkedBlockQueue。线程A主要工作就是，从queue中take()出一个资源，但是处理相关逻辑，然后循环。

所以在脚本执行完毕后，需要给线程一个通知，当队列为空时，自动退出循环结束线程。然后在主线程中等待theadA.join()即可。

然后的问题是，LinkedBlockQueue.take()是无限等待的，所以还需要执行theadA.interrupt()才能够跳出这个无限等待的API。

但是如果执行theadA.interrupt()时，队列还不为空，就会出问题。

所以使用LinkedBlockQueue.poll(long timeout, TimeUnit unit)，就不需要执行theadA.interrupt()，也能够判断到队列为空自动退出循环了。

但是有超时时间的poll方法性能上应该要比无超时时间的take()要低，而且正常执行过程中当队列为空时反复超时跳出等待再进去新的等待，浪费CPU。

这是个有点纠结的问题。

以下代码，用stop()来立刻停止线程（无论queue是否还有剩下的未处理），用interrupt()来等待处理完queue中所有后再退出。

这里或者可以在interrupt()中返回queue.size()，根据返回的size若为0可以执行theadA.interrupt()，不为0则不执行，但是又有问题同步队列的size()方法会引起线程同步的问题（size()方法并没有太大的意义）。

running和interrupt变量是会在不同的线程write和read的，所以必须要用volatile修饰，保证一致性

private volatile boolean running = true;
public void stop(){
	running = false;
}
private volatile boolean interrupt = false;
public void interrupt(){
	interrupt = true;
}
 
@Override
public void run() {
	while(running){
		try {
			Object obj = null;
			try {
				obj = queue.take();
				obj = queue.poll(5, TimeUnit.SECONDS);
			} catch (InterruptedException e) {
				logger.error("used to break queue.take() infinite waiting");
			} catch (Exception e) {
				logger.error("get obj erorr", e);
			}
			if(obj != null){
				do(obj);
			}
			if(interrupt){
				int size = queue.size();
				if(size == 0){
					logger.info("interrupt after queue size == 0");
					break;
				}
				else{
					logger.info("interrupt but queue size == " + size);
				}
			}
		} catch (Exception e) {
			logger.error("erorr", e);
		}
	}
	logger.info("stop succ");
}

随便看一看

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析

FutureTask简单分析和用法

-Flyぁ梦- — Tue, 21 Jun 2016 07:54:40 +0000

Callable、Future和FutureTask，结合Executors和ExecutorService，将某些特定的计算任务交给其他线程（由统一的线程池管理），让主线程进行阻塞和等待执行结果，用在RPC服务比较直观，或者这个计算结果被多个线程所需等情况。

从整体上看，使用FutureTask降低了程序整体的效率，肯定不如在原线程中直接执行的快，而且因为主线程需要阻塞等待计算结果，所以并没有增加并发度。所以FutureTask在项目中一般也比较少见。

public class FutureTaskExample {
 
    static class Task implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            return 1;
        }
    }
 
    public static void main(String[] args) {
        // 第一种方式, 隐藏了FutureTask
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> future = executor.submit(task);
        Integer ret = future.get();
 
        // 第二种方式, 直接使用FutureTask
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        Integer ret = futureTask.get();
 
        // 第三种方式, 直接使用Thread
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask); // FutureTask实现了Runnable接口
        thread.start();
        futureTask.get();
 
        executor.shutdown();
    }
}

FutureTask的一个实用场景

当一个计算任务非常重量级，非常耗资源和耗时间（比如网络请求或者数据库请求），而且多个线程都需要等待这个计算任务的结果，这个时候FutureTask的优势就体现出来了。只要线程同步的去控制FutureTask的run()，然后所有线程都只要等待FutureTask.get()获取结果就可以了，这样子不会每个线程并发性的去多次重复执行计算任务。

很显然的一个场景就是数据库查询+缓存。比如查询某个table的id=xxx的对象，查询结果在内存缓存起来，在缓存为空的情况下并发第一次的访问可能引起多次SQL请求，使用FutureTask就可以避免这个问题。

public class MemCache<K, V>{
    private final ConcurrentHashMap<K, Future<V>> cache;
 
    private V getResultFromDB(K k){return v;}
 
    public V get(K k){
        while(true){
            Future<V> f = cache.get(k);
            if(f == null){
                Callable<V> eval = new Callable<V>(){
                    public V call() throw InterruptedException{
                        return getResultFromDB(k);
                    }
                }
                FutureTask<V> ft = new FutureTask<V>(eval);
                // 这一行避免可能的执行并发产生的多个不同的futureTask
                f = cache.putIfAbsent(arg, ft);
                if(f == null){
                    f = ft;
                    // 保证执行的一定是第一个futureTask
                    ft.run();
                }
            }
            try{
                return f.get();
            } catch (CancellationException e){
                // 避免缓存污染（一个计算被取消或者异常，未来获取不到值），则要从缓存中移除
                cache.remove(k, f);
            } catch (ExecutionException e){
                throw e;
            }
        }
    }
}

FutureTask源码分析

也是类似一把共享锁，所有get操作都是试图进行acquireShared加锁，当然在run执行完毕之前，会一直加锁失败并阻塞；run中执行callable.call()结束，设置计算结果值V后，进行releaseShared解锁后，所有get操作被唤醒并拿到结果值V。如果执行中途执行cancel，也会进行releaseShared解锁，所有get操作会拿到null结果值。

state值用来保存task的执行状态值，0是初始态，1表示running，2表示ran done，4表示cancel。

随便看一看

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析

Semaphore简单分析

-Flyぁ梦- — Tue, 21 Jun 2016 06:36:11 +0000

java.util.concurrent.Semaphore

AQS实现的一个变种，用来预先设置一个阈值（可进入量），然后当做类似共享锁的方式地进行acquire和release，但是每次acquire不记录当前acquire的线程对象（这是Semaphore和Lock最大的区别），即线程A操作的acquire可以由线程B来release。也有公平和非公平两种方式。

一般用在管理一个对象池，设置初始容量N，每次getObject就acquire，每次returnObject就release，因为没有对对象池本身采用任何同步加锁代码，即使线程A的acquire在阻塞中，线程B的release依然可以进行。

Semaphore的最大容量也可以动态增加，可以通过release和release(int n)持续扩大容量（即使没有任何线程进行acquire）（虽然API名称上不直观）。

AQS的代码解析见：可重入锁、ReentrantLock、AQS、Condition

reducePermits和nonfairTryAcquireShared的区别在于，reducePermits不管减少容量后的state值是多少（可以为负值）阻塞等待CAS完成，nonfairTryAcquireShared则需要判断减少容量后的state值是正值则阻塞等待CAS完成，负值则返回acquire失败回到AQS中加入Sync队列。

看看锁

2016-08-18 -- 读java concurrency in practice
2016-06-17 -- CountDownLatch简单分析
2016-06-16 -- ReentrantReadWriteLock简单分析
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-17 -- CountDownLatch简单分析

CountDownLatch简单分析

-Flyぁ梦- — Fri, 17 Jun 2016 10:18:30 +0000

也是利用AQS实现的一个变种，用来预先设置一个阈值（任务数）后主线程调用await()持续阻塞，然后由其他线程执行任务，执行完后调用countDown()将阈值减1，当所有任务执行完毕，阈值减为0，主线程await()被唤醒跳出阻塞，继续执行。

使用例子

public class CountDownLatchDemo {
 
    public static void main(String[] args) throws InterruptedException {
    	CountDownLatch latch = new CountDownLatch(2); // 两个任务线程
    	Worker worker1 = new Worker("A", latch);
    	Worker worker2 = new Worker("B", latch);
    	worker1.start();//
    	worker2.start();//
 
    	latch.await(); // 阻塞等待所有Worker线程结束
        System.out.println("all work done");
    }
 
    static class Worker extends Thread {
    	private CountDownLatch latch;
    	public Worker(String workerName, CountDownLatch latch){
    	    this.latch = latch;
    	}
    	public void run(){
	    try{
	        doWork();
	    }
            // 必须放在finally中保证能够释放（不然出异常主线程无法恢复）
	    finally{
	        latch.countDown(); //线程执行结束, 计数器减1
	    }
    	}
    } 
}

源码分析

针对AQS的分析见：可重入锁、ReentrantLock、AQS、Condition 和 ReentrantReadWriteLock简单分析。

CountDownLatch的内置Sync类相当简单

构造函数，初始化count值，写入AQS的state（相当于已经有count的对象持有锁）
主线程调用await()方法，就是执行AQS.acquireSharedInterruptibly，而Sync.tryAcquireShared，只有当state == 0才能够acquire成功（即只有当count减为0，await才会跳出阻塞）
其他线程调用countDown()方法，就是执行AQS.releaseShared(1)，而Sync.tryReleaseShared，最简单的无限循环阻塞保证release成功
多于count数量的执行countDown()方法，不会再更新state值，state减为0就不变了
多次await也没有意义，在state==0后，await操作就是共享加锁，都可以瞬间成功

看看共享锁 , 锁

2016-06-16 -- ReentrantReadWriteLock简单分析
2016-08-18 -- 读java concurrency in practice
2016-06-21 -- Semaphore简单分析
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

ReentrantReadWriteLock简单分析

-Flyぁ梦- — Thu, 16 Jun 2016 11:49:10 +0000

AQS的另一个实现，可重入的读写锁，其中读锁是共享锁，写锁是排他锁。用法和ReentrantLock基本一致。

ReentrantLock的源码分析见：可重入锁、ReentrantLock、AQS、Condition，作为本文的铺垫。

ReentrantLock利用AQS的state值作为重入次数记录，所以理论上可以重入int的最大值；ReentrantReadWriteLock同样利用AQS的state值来作为重入次数记录，只不过32位的int值，前16位用来记录读锁的重入次数，后16位用来记录写锁的重入次数，所以读锁和写锁的可重入次数最多都只有65535次。

ReentrantReadWriteLock的代码结构和ReentrantLock基本一致，先有一个Sync类继承自AQS实现了全部的写锁和读锁的加锁、解锁代码，然后再有UnfairSync和FairSync继承自Sync来实现非公平和公平策略，两个子类中只实现了readerShouldBlock()和writerShouldBlock()。不同的是，还有两个新的类，ReadLock和WriteLock，内部持有Sync实例，ReadLock的lock()和unlock()调用acquireShared()和releaseShared()，WriteLock的lock()和unlock()调用acquire()和release()，都只是对Sync实例方法的直接调用，没啥可看的东西。

Sync类

state值拆分

一开始的SHARED_SHIFT、SHARED_UNIT、MAX_COUNT、EXCLUSIVE_MASK变量就是对state值进行前16位和后16的拆分，还有后面sharedCount()和exclusiveCount()方法。

针对每个线程的读锁的HoldCounter

state值的前16位，记录了所有线程的读锁的重入次数，所以每个线程中还要自己单独在记录一下读锁重入次数（才能做到读锁的重入和释放）。这个数据就保存在HoldCounter类中，并用ThreadLocalHoldCounter extends ThreadLocal类来存储。

HoldCounter cachedHoldCounter这个变量可以无视，缓存上一次进入读锁的HoldCounter对象，没有这个功能也没太大影响每次都从ThreadLocal中取就可以了，只是提高了效率。

Sync类的子类，UnfairSync和FairSync

都只实现了writerShouldBlock()和readerShouldBlock()方法。

FairSync简单，所有试图acquire锁都必须是Sync队列中的first才行，保证公平性。

UnfairSync的write操作，没有任何需要Block的场景，而read需要判断Sync队列的first是否是写（独占）请求，表明了写的优先级比较高，读在很多情况下要给写让步，防止写锁饥饿。

代码实现

写锁的实现

调用AQS.acquire和AQS.release实现，然后通过Sync.tryAcquire()和Sync.tryRelease()实现，和ReentrantLock基本没有差别。在tryAcquire中既要判断state的互斥部分（是否有写锁占用），也要判断state的共享部分（是否有读锁占用）。

读锁的加锁实现

调用AQS.acquireShared和AQS.releaseShared实现，然后通过Sync.tryAcquireShared()和Sync.tryReleaseShared()实现。

Sync.tryAcquireShared（此方法阻塞至acquire成功或者返回失败）

判断是否被写锁占用且当前线程不是写锁拥有者，return -1
判断读锁重进入总数（所有线程）是否超过最大值
根据公平性原则（Sync子类的readerShouldBlock()方法），判断是否可以加读锁
然后就尝试CAS加锁，若成功则获取当前线程的HoldCounter对象，更新count++（更新缓存hc对象），return 1
CAS miss，call fullTryAcquireShared()
fullTryAcquireShared 循环开始（此方法阻塞）
判断是否被写锁占用且当前线程不是写锁拥有者，return -1
再判断(rh.count | w) == 0 && readerShouldBlock(current)，(rh.count | w) == 0就是rh.count == 0 || w == 0（当前线程未占有读锁或未占用写锁，即除了占有写锁后的读锁重进入的情况），都要根据公平性原则（Sync子类的readerShouldBlock()方法），判断是否可以加读锁
判断读锁重入是否超过最大值
尝试CAS加锁，若成功更新rh.count++，return 1
CAS miss，回到循环开始，步骤6

官方注释中说，fullTryAcquireShared方法handles CAS misses and reentrant reads not dealt with in tryAcquireShared，其中CAS miss是很好理解的，但是reentrant reads还真没看出来（读重入完全有可能在tryAcquireShared的CAS里就完成了呀，可能作者的意思是读重入因为并发比较高所以容易CAS miss？）。

AQS.acquireShared

在执行完Sync.tryAcquireShared失败时，会call AQS.doAcquireShared，将线程添加到AQS的Sync队列中，并循环等待加锁成功，类似独占锁执行的AQS.acquireQueued方法。

AQS.doAcquireShared

添加节点到AQS的Sync队列中
无限循环开始
判断当前节点若是first节点，到步骤4，若不是到步骤6
call tryAcquireShared，若加锁成功到步骤5，若失败到步骤6
call setHeadAndPropagate，更新Sync队列的head节点，并在一定条件下调用AQS.doReleaseShared，并跳出循环返回
判断当前节点线程是否需要park，并执行线程park
回到循环开始，步骤2

doAcquireShared和acquireQueued的区别在于，加锁成功后，acquireQueued仅仅就是更新了head节点，而doAcquireShared不仅更新了head节点，还会在一定条件下call doReleaseShared方法去激活下一个等待的节点。

AQS.setHeadAndPropagate和AQS.doReleaseShared

这一点可以理解为，因为doAcquireShared是获取共享锁，获取共享锁的前提是没有独占锁被持有，而共享锁被一方获取后，其他方可以同时去尝试获取共享锁，所以可以来激活下一个等待的是共享模式的节点线程，提高效率。这样子可以把Sync队列中依次顺序的共享锁请求全部打开并满足，提高了并发。

所以这里也可以看出，当一个线程获得写锁后，并不是所有等待写锁的线程都会被激活并获得共享写锁，因为Sync队列中是按照公平原则来的，只要队列中有一个独占锁请求（写锁），后面的共享锁（读锁）请求是依然被阻塞的，按照时间顺序保证了这些读锁请求会在写锁之后执行，读到新的数据。

读锁的解锁实现

解锁的简单了，调用Sync.tryReleaseShared()，解锁成功后调用AQS.doReleaseShared()，激活下面节点的线程。

Sync.tryReleaseShared（此方法阻塞至release成功，返回是否锁被释放）

读锁与写锁的实现区别

读锁（共享锁）的加锁的阻塞，在Sync.fullTryAcquireShared中也有实现（在Sync中出现acquire失败后才进入AQS里的阻塞实现），而在Sync中实现acquire成功，是不会调用AQS.doReleaseShared去对下面节点进行线程唤醒的（这个就有点不明白了）。

ps：读锁（共享锁）的加锁这一块是最复杂的，理解也还不甚到位。

读锁（共享锁）的解锁也需要在阻塞，也在Sync中实现，因为共享锁在解锁时也存在并发；而写锁（独占锁）是不需要阻塞实现的，因为解锁的时刻肯定是只有当前线程可以操作锁对象，不存在并发。

tryReadLock和tryWriteLock

这两个方法acquire的逻辑和普通的lock没有区别，除了少判断了writerShouldBlock()和readerShouldBlock()方法，即失去了公平性保证也抛弃了写优先于读的策略。

看看共享锁 , 并发 , 锁

2016-08-18 -- 读java concurrency in practice
2016-06-17 -- CountDownLatch简单分析
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition
2016-06-21 -- Semaphore简单分析
2015-01-07 -- 防止数据库数据重复的几种方法

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

可重入锁、ReentrantLock、AQS、Condition

-Flyぁ梦- — Mon, 13 Jun 2016 13:51:14 +0000

本文简单介绍可重入锁的概念，简单介绍java中内置的synchronized锁和java.util.concurrent.locks.ReentrantLock，然后大致介绍下ReentrantLock的代码实现。ReentrantLock和AQS代码逻辑真心复杂和难懂，尤其是AQS中Node的ws值中的SIGNAL值的用法和线程park/unpark的用法，持续几周看了好几天终于算是给弄明白了！

可重入锁

可重入锁，这是一个理论范畴的概念，具体可自己查询。意思就是，在当前线程已经获取锁的情况下，可以再度获取锁而不会引起死锁。最好理解的就是java代码中最常见的synchronized锁，它就是一个可重入锁，因为同为synchronized修饰的方法A和B，在A中call B，是没有问题的，从A到B的过程就是锁的重入。

所以很好理解，可重入锁需要在内部维持一个进入次数N和占有锁的线程对象S，当N == 0时表示锁闲置，获取锁时set N = 1并set S = currentThread，每次进入锁N++，每次退出锁N–，直到N == 0锁被释放并set S = null，当然前提所有操作要保证currentThread == S才行。

synchronized锁和ReentrantLock

两者都是可重入锁

区别在于：

synchronized	ReentrantLock
语法内置，自动加锁和释放锁得到保证	手动lock和unlock，unlock需在finally中，否则临界区代码异常会引起死锁
非公平锁	提供默认的非公平锁和公平锁实现
	加锁API丰富，lock、tryLock、lockInterruptibly、tryLock(timeout)
利用object或者class作为锁本身来wait和notify	提供Condition机制来await和signal，更灵活和好理解
使用难度低，效率偏低	使用难度较高，效率更高

虽然效率上Reentrantlock偏高，但如果不熟悉可能会引起更多问题，在大多数情况下理应优先使用synchronized，只有在需要利用ReentrantLock的公平机制、其他lock API的情况下，或者对于效率有着非常严格要求的情况下，才推荐使用ReentrantLock。

ReentrantLock与AbstractQueuedSynchronizer

ReentrantLock是AbstractQueuedSynchronizer（AQS）的一个实现（不是子类），绝大部分的实现都在于AQS之内，AQS仅仅暴露了几个API供子类实现，而ReentrantLock仅仅实现了其中两个：

protected boolean tryAcquire(int arg)：尝试加锁
protected boolean tryRelease(int arg)：尝试解锁

AQS内部数据结构

静态内部类Node，作为一个双向list的节点，存储有线程对象和一个状态值，以及另外一个变量表明是否为独占
Node head, tail 节点，维护Node的双向list，此为等待加锁的线程节点Sync列表
int state值，供子类使用，可表示不同意义；在Reentrantlock中表示重入锁次数
内部类ConditionObject，每个ConditionObject内部维护一个Node队列，是为等待此condition的线程队列

AQS中Node的waitStatus（以下简称ws值）状态值

0，正常状态，不停地尝试去获取锁
1，CANCELLED，表示此节点已被Cancel，退出竞争锁
-1，SIGNAL，表示当前node在release时后面的节点需要被唤醒
-2，CONDITION，表示当前node在某一个ConditionObject的等待队列中，不在Sync队列中
-3，PROPAGATE

AQS中Node的nextWaiter节点

nextWaiter == Node.EXCLUSIVE == null，表明为独占

nextWaiter == Node.SHARED== new Node()，表明为共享

ReentrantLock中的Sync、NonfairSync、FairSync

Reentrantlock中的Sync才是AQS的直接子类，nonfairTryAcquire()方法实现了非公平锁的实现，并实现了tryRelease()方法，基本就是通过CAS原理，通过AQS的state值和ownerThread来实现，很好理解。

NonfairSync又是Sync的子类，tryAcquire()直接调用nonfairTryAcquire()。

FairSync也是是Sync的子类，单独实现tryAcquire()，比nonfairTryAcquire()多了一个isFirst(current)的判断，就保证了公平性。后面会具体讲。

AQS中对线程的park和unpark

利用unsafe实现的，对线程挂起和唤醒的操作。

有2个地方会引起线程park

ConditionObject.await方法，使得当前线程节点进入condition队列
AQS.acquireQueued的循环中，当前线程节点的prev节点的ws值为SIGNAL

有2个地方会引起线程unpark

ConditionObject的doSignal方法，使得线程节点从condition队列移除，添加到Sync队列，若prev节点被Cancel了或者设置prev.ws为SIGNAL失败，则立即激活本节点线程
当前线程节点的prev节点线程抢占锁并release，且prev.ws == SIGNAL，唤醒next节点

ReentrantLock的代码实现

此部分内容，不考虑cancelAcquire操作、其他lock操作和线程中断等复杂情况，以最基本的逻辑讲述。

非公平锁的lock

新的线程，在NonfairSync.lock中直接尝试CAS加锁，成功则返回
若失败，call AQS.acquire(1)，1表示进入次数加1
AQS.acquire：!tryAcquire(n) && acquireQueued(addWaiter(Node.EXCLUSIVE), n)
调用子类的tryAcquire再试一遍加锁：即Sync.nonfairTryAcquire()，通过CAS尝试加锁或者计算重进入，成功则返回
若失败，回到AQS.acquire，执行acquireQueued(addWaiter(Node.EXCLUSIVE), n)
AQS.addWaiter，新建Node节点（独占），通过AQS.enq方法无限循环保证（阻塞式地）添加到Sync队列中
AQS.acquireQueued，无限循环开始：判断节点是否为Sync队列中的first有效节点并call tryAcquire尝试加锁，若成功，移除原head，设置新head = first，返回
循环中：若失败，call AQS.shouldParkAfterFailedAcquire判断node是否需要被park，然后park当前线程
循环结束，回到步骤7

第1、4步中可以看到，新的线程尝试加锁可以无视Sync队列中等待的其他线程直接尝试加锁（而且代码更简单效率更高，如下图中的黄色快速通道所示），此为非公平性原理

AQS中的同步队列与加锁通道

第7步中得知，在Sync队列中等待的线程，是严格按照先后顺序获取锁的。所以是非严格的非公平性。
第8步中shouldParkAfterFailedAcquire的原理，若node.prev的ws为SIGNAL，返回true; 否则，尝试set node.prev.ws = SIGNAL并返回false（在下一次的循环中，就可能会返回true了）

公平锁的lock

和非公平锁的区别就在于

没有第1步，直接进入AQS.acquire(1)
FairSync.tryAcquire中，需要额外判断Sync队列为空或当前线程是Sync队列中的first才尝试CAS加锁，成功则返回
从第5步开始完全一致

取消非公平锁的第1步，调整第4步，就保证了严格按照Sync队列来获得锁，即为公平性。

unlock

公平锁和非公平锁的unlock操作是一样的，通过调用AQS.release(1)实现

call Sync.tryRelease，就是通过CAS将state – 1，若最后state > 0，锁还未释放，返回
若最后state == 0（锁被释放），若head节点（上一个加锁成功的节点）的ws值 != 0（就是为SIGNAL的情况下）， call AQS.unparkSuccessor(head)
AQS.unparkSuccessor(node)：先CAS设置node.ws = 0
在node节点后找到第一个没有被cancel（ws值 <= 0）的节点，尝试将其unpark（这里要unpark的next线程节点，不一定真的被park了，就是保证next节点的线程可以work来抢锁）

AQS中Condition的实现

condition被新建时，就在内部维护了一个队列

condition.await

addConditionWaiter()，将当前线程新建为Node，设置ws值为CONDITION，添加到condition的队列中
call AQS.fullyRelease，将当前线程获得的锁完全释放（即无论重入几次，state之间减为0）
无限循环开始：当node.ws == CONDITION或node不在Sync队列中，park线程
等待condition被其他线程signal或signalAll了，节点ws值被修改且被移回Sync队列中（循环条件被打破），但此时线程仍在park中
在Sync队列中，node.prev得到锁并释放后，node节点线程被unpark
跳出循环，call acquireQueued()，进入正常锁竞争逻辑

condition.signal和condition.signalAll

将condition的队列中的first节点或者全部节点，调用condition.doSignal()，然后就是调用AQS.transferForSignal()

首先将本节点的ws从CONDITION设为0
call AQS.enq，将节点加入到Sync队列中
判断node.prev.ws值为CANCELLED，或者设置node.prev.ws = SIGNAL失败，直接将本节点线程unpark

经过这3步，就可以打破await中的循环条件，然后当node.prev得到锁并释放后，node节点线程被unpark

看看并发 , 锁

2016-08-18 -- 读java concurrency in practice
2016-06-16 -- ReentrantReadWriteLock简单分析
2016-06-21 -- Semaphore简单分析
2016-06-17 -- CountDownLatch简单分析
2015-01-07 -- 防止数据库数据重复的几种方法

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Tomcat监听shutdown释放数据库连接池

-Flyぁ梦- — Wed, 08 Jun 2016 12:41:47 +0000

开发时因为更新代码，频繁重启Tomcat，遇到一个问题：在执行shutdown脚本后，Tomcat进程没有关闭依然存在（但是HTTP服务已经停止），需要手动执行kill命令才行。查了一些资料结合经验，应该是所使用的数据库连接池中的连接没有被释放的问题引起的。所以解决的办法，就是想办法做一个Tomcat的shutdown的事件监听，然后手动释放数据库连接即可。

Tomcat的shutdown的事件监听

很简单，实现一个ServletContextListener的实例，并注册到web.xml中即可。

public class ShutdownListener implements ServletContextListener  {
 
	private static Logger logger = Logger.getLogger(ShutdownListener.class);
 
	@Override
	public void contextDestroyed(ServletContextEvent arg0) {
		logger.info("contextDestroyed");
		logger.info("DBPool shutdown start...");
		try {
			DBPool.clear();
			DBPool.close();
		} catch (Throwable e) {
			logger.fatal("", e);
		}
		logger.info("DBPool shutdown done");
	}
 
	@Override
	public void contextInitialized(ServletContextEvent arg0) {
		logger.info("contextInitialized");
	}
 
}

>
    >xxx.xxx.xxx.ShutdownListener>
>

数据库连接池的关闭和释放

代码中没有使用复杂的数据库连接池，是用org.apache.commons.pool.impl.GenericObjectPool和org.apache.commons.pool.BasePoolableObjectFactory组合实现的。

在ServletContextListener的contextDestroyed方法中

执行GenericObjectPool.clear()，是将池内缓存的对象全部销毁
执行GenericObjectPool.close()，关闭对象池，不再支持borrowObject()，但依然支持returnObject()方法且return后将对象立即销毁

做完这两步，执行Tomcat的shutdown脚本后，Tomcat进程过几秒就会自动关闭了。

看看 Tomcat , 数据库 , 进程

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Tomcat启用https服务

-Flyぁ梦- — Mon, 06 Jun 2016 14:27:44 +0000

第一步，获取证书

这个就去百度吧，既有免费证书，也有收费的证书，当然收费的证书会更靠谱更受大众认同（比如GeoTrust的）。

然后证书分为3个等级，DV（Domain Validation，证明当前站点在指定域名下，最常见的），OV（Organization Validation，证明当前站点在指定公司or组织下，浏览器会在URL前显示公司名称的），EV（Extended Validation，比OV更加复杂安全的证书，一般为网银所使用）。

这里选择国内的免费证书：https://www.wosign.com/

在它家网站上注册用户，申请免费证书，要填写指定的域名地址和证书保护密码，然后就可以下载到证书了。下载的zip包里有专门供tomcat使用的jks证书。

第二步，部署https

将apache-tomcat/conf/server.xml中原来被注释的打开，如下配置：

 port="443" protocol="org.apache.coyote.http11.Http11NioProtocol"
    acceptCount="100" executor="tomcatThreadPool" URIEncoding="UTF-8" 
    compression="on" compressableMimeType="text/html,text/css,application/javascript"
    SSLEnabled="true" scheme="https" secure="true" clientAuth="false" sslProtocol="TLS"
    keystoreFile="/home/.../xxx.com.jks" keystorePass="xxxxxxx"
/>

这里的配置要和的配置要完全一致，第一行是基础协议，第二行是优化参数和设置编码，第三行是开启静态资源压缩，最后两行是对于SSL特殊的设置。

在https的Connector中忘记加上URIEncoding="UTF-8"，会导致https中文异常而http正常
（http的自带这个属性）

第三步，http自动跳转到https

给加上属性redirectPort="443"，这个默认就有。

然后再修改apache-tomcat/conf/web.xml，最后加上一段：

    >
        >
            >Protected Context>
            >/*>
        >
        
        >
            >CONFIDENTIAL>
        >
    >

搞定

第三步，https的注意事项

在https下，如果页面内还存在有http链接的内容（图片、js等静态资源），则会产生警告，并在浏览器URL栏中失去绿色锁的标志
在https下，如果页面内企图发起http的post请求，则会默认被浏览器禁止，并产生警告

看看 HTTPS , Tomcat , 安全 , 证书

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Tomcat开启gzip压缩

-Flyぁ梦- — Thu, 26 May 2016 03:10:47 +0000

 
    port="8080" 
    protocol="org.apache.coyote.http11.Http11NioProtocol" 
    acceptorThreadCount="8" 
    executor="tomcatThreadPool" 
    URIEncoding="UTF-8" 
    compression="on"
    compressableMimeType="text/html,text/css,application/javascript,text/xml,text/plain"
    connectionTimeout="20000"
    redirectPort="8443" 
/>

主要是compression和compressableMimeType两行。

Tomcat7中，必须是application/javascript，而不能使text/javascript。

注意如果开启了https服务，在中也别忘了设置开启compression和compressableMimeType两行。

随便看一看

2012-05-13 -- Java Play framework
2010-09-15 -- 一篇风趣的小说
2010-12-16 -- wp-sns-share更新至1.4
2011-04-28 -- 货币战争：金权天下
2010-08-17 -- 三国情

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Spring-MVC中的一些问题

-Flyぁ梦- — Tue, 22 Mar 2016 13:52:10 +0000

想法：Spring-mvc（Spring v3.2）中，仅对注册过（通过@RequestMapping注解）的url进入到controller层，其他非法url在Filter里就拦截掉，统一处理节省资源。因为在filter的doChain之前，给本次请求从对象池中获取一个操作db的对象，对无效url也分配的话就浪费了资源。

实现：通过Spring-mvc的RequestMappingHandlerMapping来获取注册过的url path，再根据HttpServletRequest，判断下就可以进行过滤。

自己实现

一开始，自己新建一个类用一个HashMap去保存所有的url path即可，在controller中的static域或者构造方法里，添加本controller中的所有url path即可。

问题一：spring日志显示已经初始化完毕绑定了url了，但是并没有触发controller中的static域或者构造方法！

不得不使用Class.forName()去强制触发static域。

原因：spring-servlet.xml中根标签加了default-lazy-init=”true”，所有controller在有真正http请求到来才会被访问到！

问题二：spring日志显示明明有url记录，为啥要再自己干？

日志显示一个叫RequestMappingHandlerMapping的东西显然保存了url注册，拿到这个bean的实例应该就大功告成。

通过RequestMappingHandlerMapping

问题三：在Filter里用WebApplicationContextUtils.getWebApplicationContext(ServletContext)的方法拿到ApplicationContext后，但是拿不到bean

这个ApplicationContext里面根本没有任何bean！

原因：这个ApplicationContext是针对applicationContext.xml建出来的Root ApplicationContext，而Spring MVC根据spring-servlet.xml建立的是一个Child ApplicationContext

问题四：在Filter里无法获取到spring-servlet.xml建立的Child ApplicationContext

因为通过Root ApplicationContext拿不到Children，也没有任何API可以直接获取Child ApplicationContext。

原因：Filter是直接注册在web.xml中的，并不归Spring管理，Spring MVC根据spring-servlet.xml建立ApplicationContext只能注入到同一个Spring容器中的bean，比如所有controller中。

于是新建一个类交给Spring管理（在spring-servlet.xml中定义bean），然后implements ApplicationContextAware，就可以获得Spring MVC的ApplicationContext了，自然就拿到了RequestMappingHandlerMapping的bean，将其保存下来，通过判断requestMappingHandlerMapping.getHandler(request) == null即可知道是否为有效url path。

看看 Spring

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Java最外层异常的抓取要用Throwable

-Flyぁ梦- — Tue, 22 Mar 2016 13:26:26 +0000

3月以来，从来运行正常的link无故崩了好多次，现象：无异常日志，用jstack看主线程挂了进程还在，主线程最外层有catch异常，但是并没有打印日志，实在匪夷所思。

先是怀疑socket连接，通过系统监控看到socket连接数在1w左右，进程ulimit 65536，无内核相关日志。

这时候用jstat分析内存使用，发现link的YGC和FGC增长非常迅速，而且老年代常年在90%以上经常在95%以上，几秒到十几秒一次FGC，一秒2-3次YGC。显然内存已经在崩溃边缘，这时候就想到了可能因为内存不够抛出了OutOfMemoryError，因为是Error，catch Exception无法捕捉！但是在测试机手动模拟抛出OutOfMemoryError，却引发了整个进程的挂掉而不仅仅是主线程。不过这里提供了思路，应该是抛出了某种Error。

无奈对link进行修改重新编译打包（毕竟这个工程从来没有动过，而且非常关键重要，一直不敢改动），将最外层的catch Exception改为catch Throwable，还加上了UncaughtExceptionHandler的实现来捕获主线程可能未捕捉的异常。同时将link的内存从默认值（48g的机器，应该默认为12g）直接加大到24g。运行后一段时间，内存使用情况过度良好，完全没有FGC了，YGC也很少，看来是吓怕了给了太多了内存了。本来以为加大了内存后不会再崩了，坚持了很久之后终于又崩了一次，抓取到了Error找到了原因！

原来是因为热部署修改app时，修改了与link共用的common.jar包后引起的java.lang.NoClassDefFoundError，怪不得了。其实一直就有在怀疑这个在app中会出现的问题，怎么在link中一直没出现过，果然不是偶然啊，虽然在近期才大量爆发之前一直安然无恙也是比较奇怪。引起NoClassDefFoundError的类，与上次部署时修改的一个类处于同一个package下，不知道是不是直接原因。

最外层异常的抓取要用Throwable啊！

至于Java进程运行后替换jar包引起的NoClassDefFoundError问题，值得具体再研究！

随便看一看

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Java客户端Socket在服务端重启后的异常情况处理

-Flyぁ梦- — Thu, 17 Mar 2016 11:25:04 +0000

碰到场景如下：Java服务器端A（使用NIO的异步IO方式），Java客户端B（使用普通IO的同步方式），在服务端A重启后，B->A的Socket毫无疑问的断了，然后就会出现一些异常情况，分析一下。

同步IO客户端既发也收

在服务端A重启后，B再次发送数据到A（虽然socket连接已断，但这个过程无异常，但其实数据并无法发送），然后B从A读数据的结果中，inputStream.read(byte[] array)会返回-1，表示end-of-file。

这种情况就比较好处理，在底层获取到end-of-file后抛出个异常，上层捕获异常后通知底层进行新建socket重连，然后上层再重发数据再读回包即可。

同步IO客户端只发不收

在服务端A重启后，B尝试第一次发送数据到A（虽然socket连接已断，但这个过程无异常，检测socket.isConnected()=true或者socket.isClosed()=false也都显示正常，但其实数据并无法发送），当B第二次再发送数据到A，在outputStream.write中，会报异常java.net.SocketException: Broken pipe。

所以通过抓取异常重连重发的办法，要在第二次发送失败时才能被发现并work。

客户端不发只收

这种情况在实践中感觉比较少见，即使业务逻辑如此，客户端应该也要发送心跳包到服务器，然后就是既发也收了。

异步IO客户端

如果客户端也是NIO的异步IO方式，在服务端A正常关闭时，客户端B会接收到SelectionKey.isReadable() == true的通知，然后从SocketChannel中read返回-1值，表示EOF，就可以处理关闭链接，然后下一次write的时候就可以进行重连了。

如果是服务端非正常关闭，比如断电、宕机等情况，有待验证，理论上应该不会返回read通知也不会返回-1的结果。

看看 Socket

2013-05-20 -- Tomcat的Connector：Coyote
2013-05-19 -- Tomcat6源码学习

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

警惕long值转化为int，比如在Comparator接口中

-Flyぁ梦- — Wed, 02 Mar 2016 08:39:52 +0000

long值转为int会造成溢出大家都知道，很多时候却会忽视已发bug，造成明明的正值变为了负值（因为int最高位非0，long值大于int最大值2^31-1=2147483647）。

此次出错的地方在使用java.util.Collections.sort中使用Comparator接口中，因为compare方法通过返回int值来比较大小，而逻辑比较大小是通过比较时间戳long值按最近时间排序，一开始不注意就直接把时间戳long值差给直接转为int值返回了，造成了可能的排序错误（有趣的是只需要24天的毫秒值就会超过int的最大值）。

错误代码如下：

Collections.sort(list, new Comparator(){
	@Override
	public int compare(Message o1, Message o2) {
		return (int)(o2.timestamp - o1.timestamp); // wrong
	}
});

显然，我们只要简单的比较2个时间戳long值，返回1和-1即可。

修正代码如下：

Collections.sort(list, new Comparator(){
	@Override
	public int compare(Message o1, Message o2) {
		if(o2.timestamp > o1.timestamp){
			return 1;
		}
		else{
			return -1;
		}
	}
});

随便看一看

2010-12-14 -- wordpress中播放音乐
2011-07-01 -- 毕业季，厦门行
2016-02-16 -- 仙剑六-剧情视频感受
2012-09-11 -- 读神雕侠侣
2016-05-26 -- Tomcat开启gzip压缩

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

jdk中SimpleDateFormat的实例线程不安全

-Flyぁ梦- — Tue, 01 Mar 2016 03:59:34 +0000

线上服碰到诡异问题，解析一段无参数固定代码生成的时间字符串获得时间戳，不定概率出现解析异常，堆栈如下。

产生的原因，因为SimpleDateFormat每次new的代价比较高，固定new一个后重复使用。一开始并没有对输入字符串进行日志打印，就以为是输入字符串的错误，就难以定位到产生问题的原因。

[ERROR]2016-03-01 09:03:13,446, [Class]DateTimeUtils, getTimestampFromDateString error : 2013-02-18 09:43:18.0
java.lang.NumberFormatException: For input string: "E.179E11"
    ...
    at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1312)
    at java.text.DateFormat.parse(DateFormat.java:335)
    at com.netease.popo.common.util.DateTimeUtils.getTimestampFromDateString(DateTimeUtils.java)
    ...

明明参数传入的字符串是2013-02-18 09:43:18.0，怎么报异常就变成了E.179E11（有时候报错是空字符串，有时候提示multiple points），就很容易联想到是多线程引起的问题了。

解决的办法：

每次new SimpleDateFormat(dateTimeFormat).parse(time)，代价比较大
ThreadLocal，给每个线程新建一个SimpleDateFormat对象
线程安全的第三方库，比如joda-time（org.joda.time）或date4j（www.date4j.net），前者使用更广泛

考虑到使用ThreadLocal需要自己管理且JDK对于日期时间API的弱势，引入一个第三方库对于长远来说也很有必要。
虽然易用性上可能不如date4j更简单，考虑到joda-time使用更广泛资料更多这样也保证了安全和稳定性以及后续的维护代价

综上决定使用joda-time库。但是joda的parse功能并不强大，必须要结合具体的timeFormat才行，这点date4j要强大的多。

下面是根据时间字符串获取时间戳的一个例子，根据业务需求解析了几种常见的日期时间字符串格式。

private static final String dateFormat = "yyyy-MM-dd";
private static final String dateTimeFormat = "yyyy-MM-dd HH:mm:ss";
private static final DateTimeFormatter dateJFormat = DateTimeFormat.forPattern(dateFormat);
private static final DateTimeFormatter dateTimeJFormat = DateTimeFormat.forPattern(dateTimeFormat);
private static final DateTimeFormatter dbJFormat = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.S");
private static final DateTimeFormatter dateTimeMillJFormat = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.SSS");
 
public static long getTimestampFromDateString(String time){
	if(StringUtils.isEmpty(time)){
		return 0L;
	}
	int len = time.length();
	try {
		DateTime dateTime = null;
		if(len == 10){
			dateTime = DateTime.parse(time, dateJFormat);
		}
		else if(len == 19){
			dateTime = DateTime.parse(time, dateTimeJFormat);
		}
		else if(len == 21){
			dateTime = DateTime.parse(time, dbJFormat);
		}
		else if(len == 23){
			dateTime = DateTime.parse(time, dateTimeMillJFormat);
		}
		if(dateTime != null){
			return dateTime.getMillis();
		}
		else{
			m_logger.error("getTimestampFromDateString joda miss : " + time);
			return new SimpleDateFormat(dateTimeFormat).parse(time).getTime();
		}
	} catch (Exception e) {
		m_logger.error("getTimestampFromDateString error : " + time, e);
		return 0L;
	}
}

看看多线程

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Java项目无法加载最新的class

-Flyぁ梦- — Tue, 22 Dec 2015 06:55:09 +0000

问题

一个Java项目，无论怎么替换jar包Jar1，运行中某个类A无法加载到最新的class，一直以替换前的旧版本运行导致报错；而Jar1中新加入的类B可以被正确执行，每次替换jar包都能加载到B最新的class。

背景

此Java项目依赖于2个目录加载多个jar包，bin目录和lib目录（bin优先于lib，因为在classpath中靠前），正常情况下bin目录中有1个jar包，lib目录中有很多jar包，此次替换的jar包Jar1位于lib目录。

原因

通过打印类A的class的加载路径找到答案

class.getProtectionDomain().getCodeSource().getLocation()

上一次替换Jar1时，将更新的Jar1误多传入到bin目录下一份，当然lib目录下也替换了。启动，没有问题，此时系统加载的是bin下的Jar1。

这次再替换Jar1时，就因为优先加载了bin目录下的old-Jar1，覆盖了lib目录下的new-Jar1，导致类A新的class无法被加载，而类B因为是新加入的类，却可以被加载到。

解决

删除bin目录下的old-Jar1包即可

随便看一看

2012-01-01 -- 2011年的总结
2016-03-01 -- jdk中SimpleDateFormat的实例线程不安全
2013-02-14 -- wp-zjuem，zju cc98表情系统 in wordpress
2016-09-10 -- 偶遇张家界，武陵源和天门山
2016-08-18 -- 读java concurrency in practice

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Linux下搭建Tomcat环境

-Flyぁ梦- — Fri, 28 Aug 2015 07:21:34 +0000

多年没有碰Java Web了，之前也一直在Windows下玩耍。在Linux下跑起Tomcat也折腾了一阵。

看Apache Tomcat官网，已经有Tomcat 8.x（据说支持Oracle Java 7.0标准），7.x和6.x，习惯还是使用6.0.44版本。

设置环境变量

打开~/.profile文件，或者/etc/profile文件

JAVA_HOME=/usr/.../java
PATH=$PATH:$JAVA_HOME/bin
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
CATALINA_HOME=/home/.../tomcat
export JAVA_HOME PATH CLASSPATH CATALINA_HOME

使用source ~/.profile命令重新加载文件（或重新登陆ssh即可），查看命令echo $JAVA_HOME

给Tomcat脚本加执行权限

进入$CATALINA_HOME/bin，chmod +x *.sh

然后./startup.sh，应该就能启动了

启动成功显示：

Using CATALINA_BASE: /home/.../apache-tomcat-6.0.44
Using CATALINA_HOME: /home/.../apache-tomcat-6.0.44
Using CATALINA_TMPDIR: /home/.../apache-tomcat-6.0.44/temp
Using JRE_HOME: /usr/.../java
Using CLASSPATH: /home/.../apache-tomcat-6.0.44/bin/bootstrap.jar

用netstat -ntlp显示：

tcp6 0 0 :::8009 :::* LISTEN 25424/java    # AJP服务
tcp6 0 0 :::8080 :::* LISTEN 25424/java    # HTTP服务
tcp6 0 0 127.0.0.1:8005 :::* LISTEN 25424/java  # 关闭命令接收服务

修改Tomcat启动端口，在conf/server.xml，修改Connector port="8080"中的端口号即可

以根目录启动

可以在conf/server.xml中，修改Host标签中添加一行，docBase指向含有WEB-INF的目录即可

看看 linux , Tomcat

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-06-08 -- Tomcat监听shutdown释放数据库连接池
2016-06-06 -- Tomcat启用https服务
2015-08-12 -- Liunx下搭建Rails和Nginx环境
2013-05-20 -- Tomcat的Connector：Coyote

看看 Java

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2016-08-18 -- 读java concurrency in practice
2016-08-05 -- 线程清理
2016-06-21 -- FutureTask简单分析和用法
2016-06-21 -- Semaphore简单分析

Liunx下搭建Rails和Nginx环境

-Flyぁ梦- — Wed, 12 Aug 2015 05:21:26 +0000

用rails开发轻量级web，效率最高！

安装rvm

http://www.rvm.io/

\curl -sSL https://get.rvm.io | bash -s stable

echo "source $HOME/.rvm/scripts/rvm" >> ~/.bash_profile

source /etc/profile

然后就可以在命令行中使用rvm命令了

安装ruby

安装rvm后安装ruby下载缓慢，手动在ruby.taobao.org下载ruby-1.9.3，将安装包放在rvm/archives下即可

rvm install 1.9.3-p545 （如果不指定p版本，则不一定会使用安装包，而去下载网上最新版本）

which ruby 可以找到当前版本ruby版本和位置

按照http://ruby.taobao.org/的方法，将gem的source改为https://ruby.taobao.org/

这里要大大赞一下taobao，为国内开发者提供了便利，然后严重鄙视和谴责GFW

gem sources --remove https://rubygems.org/
gem sources -a https://ruby.taobao.org/
gem sources -l
*** CURRENT SOURCES ***

https://ruby.taobao.org
# 请确保只有 ruby.taobao.org

安装mysql

apt-get install mysql-server

apt-get install libmysqlclient-dev

gem install mysql2 -v=0.2.24 gem install activerecord-mysql2-adapter

安装rails

gem install rails -v=3.0.20 3.2版本以上使用了很多新的东西，包括要安装nodejs等环境比较麻烦

rails new demo --skip-bundle

如果提示缺少必要gem的话，可以使用bundle自动安装
cd demo
bundle config mirror.https://rubygems.org https://ruby.taobao.org
bundle install

rails server或者rails s 即可启动自带的WEBrick web server

rails连接mysql

在mysql中新建数据库

修改config/database.yml

将adapter类型修改为mysql2

production:
adapter: mysql2
database: db_name
username: db_user
password: db_pawd
host: 127.0.0.1
encoding: utf8
socket: /var/run/mysqld/mysqld.sock

修改demo/Gemfile，注释#gem ‘sqlite3’，添加gem 'mysql2', '< 0.3'

然后写一个最简单的migrate文件用以测试，执行RAILS_ENV=production db:migrate

不成功的原因：
若提示无法加载libmysqlclient.18.dylib，是因为/usr/lib下没有这个文件，作一个软链接即可，前提是找到本机mysql安装位置：
ln -s /usr/local/mysql/lib/libmysqlclient.18.dylib /usr/lib/libmysqlclient.18.dylib

安装pcre和nginx

源码安装，将nginx包解压到/opt/nginx-x.x.x后，不要将/opt/nginx-x.x.x改名为/opt/nginx，因为/opt/nginx目录会在编译后自动生成。然后不要删除源码目录，安装Passenger还会用到。

这里不需要自己编译安装Nginx，因为安装Passenger的时候会需要编译安装一次

安装PCRE：apt-get install libpcre3 libpcre3-dev

若自己编译nginx，方法如下：
./configure --prefix='/opt/nginx' --with-http_stub_status_module --with-http_sub_module --with-md5='/usr/lib' --with-sha1='/usr/lib --with-http_gzip_static_module' --with-http_ssl_module --with-cc-opt=-Wno-error --with-http_secure_link_module
# 若是手动编译安装PCRE，则需要加上 --with-pcre=/opt/pcre-8.36
make
make install
然后/opt/nginx目录就出来啦，安装完毕

安装Passenger

首先是gem install passenger ，

然后进到gem的Passenger/bin目录中（可能在/usr/local/rvm/gems/ruby-1.9.3-p551/gems/passenger-5.0.16/），执行passenger-install-nginx-module脚本，选择第二种自定义安装nginx（第一种自动下载、编译、安装nginx），通过命令行输入nginx源码目录即可，之后都默认。

最后按照安装Passenger完毕给予的提示，配置nginx的conf/nginx.conf。

http {
passenger_root /usr/local/rvm/gems/ruby-1.9.3-p551/gems/passenger-5.0.16;
passenger_ruby /usr/local/rvm/gems/ruby-1.9.3-p551/wrappers/ruby;

server {
listen 80;
server_name localhost;
passenger_enabled on;
rails_env production;

location / {
root rails_project/public;
}
}
}

看看 linux , MySQL , nginx

2016-09-09 -- 64位Linux下Java进程堆外内存迷之64M问题
2015-08-28 -- Linux下搭建Tomcat环境
2013-06-23 -- 院版十大了，那就XYT一下~
2011-03-15 -- SpringMVC+Hibernate的一些配置

看看 ruby on rails

2015-04-09 -- JSON中出现解析错误的原因之一：不可打印字符
2014-12-21 -- Ruby字符串的编码
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-10-04 -- Rails中has_many等的原理
2014-07-28 -- 简析Rails：active_support 2.3.5

域名备案和博客迁移至国内

-Flyぁ梦- — Wed, 29 Jul 2015 03:46:54 +0000

一直用的dreamhost国外的主机，前些日子感觉越来越不好使，速度慢不说，经常根本无法连接上，FTP更是慢大部分时候无法上传和下载。然后国内环境又碰到好多网站设置需要域名备案号的，不然无法使用某些功能，比如国内的广告商、微信网页安全授权等。

前些日子，在微博上偶然发现阿里云虚拟主机免费使用，赶紧尝试了一个，还挺好用的，毕竟咱博客就是个小网站足够了。于是就开始了域名备案和数据迁移。

虽然有点恶心域名备案这个事情，但想想咱也不干什么坏事，毕竟国内网速快啊。

域名备案

在阿里云的备案中心，还挺方便的，主要有2个步骤比较麻烦。一个是下载网站提供的一个申请表格，打印3份签字后快递送到阿里云指定地点，也就是这边需要缴一个快递费用。另一个就是拍照，备案网站有提供线下的免费拍照服务点，杭州市区和萧山市区都有，这样应该是最方便的，萧山这个周六也可以去办，就在育才路汽车站后面。如果线下不方便，就让阿里云邮寄蓝色的幕布过来然后自己拍照。

这两步搞定，最后就是国家工信部的审核了，一般没啥大问题，我这审核了一周。

PS：在备案过程中，域名必须出于不可用状态（或者显示空内容）

PPS：备案仅仅只是个对域名和个人信息的验证绑定，网站具体内容根本都是不知道的（因为没有备案网站不能上线）；当然后期被发现网站有问题，就会被叫去喝茶了…

博客迁移

包括数据迁移和域名指向，还是搞了快2天才搞定，刷新DNS比较慢。

阿里云这个免费虚拟主机不支持二级域名绑定到具体目录，只支持域名映射到IP，然后显示根目录下的内容。然后默认情况下，虚拟主机不支持wordpress的url rewrite，需要手动添加.htaccess文件才可以。

网站容量1G，数据库容量50M，每月流量10G，对于小博客来说应该基本够用了。

现在博客速度在wifi下快的多了，5秒之内就可以打开

看看域名 , 备案 , 虚拟主机 , 阿里云

2010-12-04 -- 加速你的网站，Google page speed
2010-11-28 -- 域名更换

看看博客建站

JSON中出现解析错误的原因之一：不可打印字符

-Flyぁ梦- — Thu, 09 Apr 2015 08:59:36 +0000

JSON规范规定，字符串需要用Unicode传输，而对于ASCII码中的前32个不可打印字符（第33个字符为空格）应该转化为明文的转义模式，比如换行符0A：”\n”，出现在json中就应该是明文的\n，所以内部表示就应该是”\\n”。

所以假如一个json字符串中出现了01-1F这31个字符（00空字符倒是不会出现错误），json就会解析错误。

Ruby on Rails中的to_json方法，默认并没有将这31个字符给正确转义为json格式，会引起错误。

用Rails的console举例：

ASCII码转json测试

所以可能要手动去删除1-31号不可显示的ASCII码，除了\n\r\t之外，一般来说这些字符对于内容显示上不存在作用。

补充一点，ASCII表的最后一个字符127位为DEL (delete)，虽然可能也算不可打印字符，不过这个字符不会引起json解析错误。

附上ASCii码表：http://www.asciima.com/

一种解决办法：对to_json解析后的字符串进行字符过滤

    def to_json(options = nil)
        json_str = @data.to_json(options)
        bytes = []
        json_str.each_byte do |c|
            next if c >= 1 && c <= 31
            bytes << c
        end
        return bytes.pack('C*')
    end

随便看一看

2012-11-25 -- 玉泉、白堤、北山路
2012-02-10 -- wp_sns_share更新2.5
2015-10-12 -- 我在龙坑吃了个惊
2016-03-17 -- Java客户端Socket在服务端重启后的异常情况处理
2016-09-10 -- 最美古城，湘西凤凰

看看 Javascript , ruby on rails

2015-08-12 -- Liunx下搭建Rails和Nginx环境
2014-12-21 -- Ruby字符串的编码
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-10-04 -- Rails中has_many等的原理
2014-07-28 -- 简析Rails：active_support 2.3.5

Cordova native API和开源插件

-Flyぁ梦- — Mon, 30 Mar 2015 03:11:48 +0000

开发Cordova的APP使用到下面几个原生或者开源第三方的插件，很好用

1.Notification

org.apache.cordova.dialogs和org.apache.cordova.vibration

取代原生alert（不能控制title），提供丰富的alert、confirm等API

2.InAppBrower

org.apache.cordova.inappbrower

可以在APP内部新开一个页面打开浏览器，可以关闭

3.Network Infomation

org.apache.cordova.network-infomation

检查网络类型和状态，可以检查出当前网络是2G/3G/4G/WIFI，有事件监听断网和连网

4.Camera

org.apache.cordova.camera

调用摄像头或从文件夹中选取，可以获取图片base64后的数据

5.Screen Orientation

net.yoik.cordova.plugins.screentorientation

可以使用screen.lock等API，锁定或者解锁屏幕转动

6.BarcodeScanner

com.phonegap.plugins.barcodescanner

https://github.com/wildabeast/BarcodeScanner/ 主页地址

可以扫描二维码等，获取内部的文本信息和文本类型

看看 Cordova , 二维码 , 插件

2013-02-14 -- wp-zjuem，zju cc98表情系统 in wordpress
2010-12-05 -- 给wp-related-posts增加类目相关日志

防止数据库数据重复的几种方法

-Flyぁ梦- — Wed, 07 Jan 2015 09:22:49 +0000

在某些数据库表中，比如记录的是一些关联关系，比如某个人关注了另外一个人，person_id和target_id，这种数据表的数据如果出现了重复，可能会引起程序上其他地方的诡异bug，要尽量保持数据的唯一性。这种数据重复，要不就是插入数据时根本没有做存在检查，或者是可能由二次提交产生的比较麻烦的并发情况。

1. 代码层做同步控制，利用锁机制
2. 在数据查重时利用数据库事务 + SQL层加入排他锁，select * from xx where ... lock for update
3. 数据库层Unique检查，建表时加入unique的索引

前两个方法在代码层面，比较容易控制，第三种方法最彻底但是出现冲突时候会报异常。

不过如果在高并发的情况下，使用第三种方式然后主动捕获异常，也是很不错的甚至是最好的。

看看同步 , 并发 , 数据库

2016-08-18 -- 读java concurrency in practice
2016-06-16 -- ReentrantReadWriteLock简单分析
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition
2016-06-08 -- Tomcat监听shutdown释放数据库连接池

看看 Life in Coding

2016-09-09 -- jabber和XMPP简述原理
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-09-10 -- 记C#和Excel开发
2011-06-11 -- 2011-6-9 Google Doodle之电子琴
2011-03-10 -- 学计算机的尼玛伤不起啊！！！！！！

Ruby字符串的编码

-Flyぁ梦- — Sun, 21 Dec 2014 09:54:31 +0000

相比较于Java String的编码转换（先将String根据原字符集转化为字节数组，然后再用字节数组根据新字符集拼装成新的字符串），Ruby的字符串编码转化省去了中间字节数组的过程，直接string.encode(new_encoding)即可。

字符串与字节串

Ruby的字符串存储的都是字节，还有一个编码，根据这个编码对应的字符集来渲染字符。可以通过如下清除字符串的编码信息还原为裸的字节串：

str = '中'   #GBK编码
s1 = [str].pack('a*')   =>   "\xD6\xD0"

str = '中'.encode('UTF-8')    #转化为UTF-8编码
s2 = [str].pack('a*')   =>   "\xE4\xB8\xAD"

#Array.pack('a*')是用来向ASCII字符串结尾加入\0用的，所以会清除其他字符串的编码信息

s1.encoding.name => "ASCII-8BIT"

现在得到的s1和s2字符串都是ASCII-8BIT的编码（或者说是没有带字符集的裸字节字符串），只要加上一个编码信息，就可以还原为GBK或者UTF-8的字符串，这种方式和Java也比较像了吧。

s1.force_encoding('GBK')          =>     '中'
s2.force_encoding('UTF-8')         =>     '中'

Ruby中的字节数组，官方并没有给String直接的一个API来获取，但可以用过str.unpack('c*') 或者str.unpack('C*')来获取，前者带符号位，后者不带符号位。

str = '中'   #GBK编码
[str].pack('c*')   =>   [-42, -48]                  [str].pack('C*')   =>  [214, 208]

str = '中'.encode('UTF-8')    #转化为UTF-8编码
[str].pack('c*')   =>  [-28, -72, -83]              [str].pack('C*')   => [228, 184, 173]

UTF-8和Unicode

不清除具体原因，在Ruby 1.9.3中，UTF-8字符串和Uniocde有一种特殊的自动转化方式（低于Ruby 1.9的版本，没有Unicode的支持），会自动进行转化，只要UTF-8字节串给加上了UTF-8的编码信息，字符串就自动转化为Unicode模式了。

"\xE4\xB8\xAD".force_encoding('UTF-8') == "\u4E2D"      =>     true

将Unicode转化为UTF-8字符串：

"\u4E2D".each_byte {|b| print b.to_s(16)} => 'e4b8ad' #可见Unicode底层用UTF-8字节串存储

#字符串格式
"\u4E2D" # 底层就是UTF-8串

#双字节数字格式
0x4E2D（16进制） 或者 20013（10进制） => [0x4E2D].pack('U*') => "\u4E2D"

随便看一看

2012-09-25 -- 笑傲江湖
2016-06-13 -- 可重入锁、ReentrantLock、AQS、Condition
2013-06-21 -- 若说结局难改变，我为你绝笔阑珊《仙五前传》人物感言
2013-06-23 -- 院版十大了，那就XYT一下~
2017-10-29 -- 2017国庆超级假期广州澳门游

看看 ruby on rails

2015-08-12 -- Liunx下搭建Rails和Nginx环境
2015-04-09 -- JSON中出现解析错误的原因之一：不可打印字符
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-10-04 -- Rails中has_many等的原理
2014-07-28 -- 简析Rails：active_support 2.3.5

linux的timeout处理wkhtmltopdf进程超时

-Flyぁ梦- — Sat, 25 Oct 2014 14:16:17 +0000

rails程序中要调用一个系统命令，但是这个系统命令在某些时候可能会处理很久也得不到结果，就需要控制超时情况。

一开始用ruby的Timeout.timeout方法，首先这方法不是很好用，然后这个方法会开启一个新的线程处理block中的代码，然后当发生超时情况时，即抛出了Timeout::Error异常，是可以处理超时情况，但是那个被开启的线程无法管理，甚至会影响到rails的终端（不能正常Ctrl-C结束了），并且调用系统命令所开启的新进程并不会被中止仍然是继续在后台执行。

听了quark大牛的方法，尽量不要使用ruby的timeout方法，使用靠谱又简单的linux timeout命令。

timeout -k 1 10s cmd 即可

不指定-s，就默认超时后向进程发送TERM信号，即普通的kill

-k 1是指，当10s之后向超时进程发出TERM信号后，在又1秒之后向超时进程发出KILL信号

在ruby中，用ret = `timeout`就可以直接调用系统命令，然后根据ret返回值进行判断是否超时。

————————————–wkhtmltopdf的分割线——————————————–

PS：要用timeout处理的命令是wkhtmltopdf，将HTML页面转化为PDF的开源神器，但是在国内的环境中遇到HTML页面中有被墙了的页面的话，就是执行很久的时间（和浏览器一样），为了防止服务器处于假死状态，需要控制这个执行的时间。

然后顺便说下使用wkhtmltopdf过程中遇到的坑

转化HTML中的图片，如果不成功的话，试着尝试使用xvfb-run --server-args="-screen 0, 1280x1024x24" wkhtmltopdf
若转化过程中中文出了问题，检查linux中的微软雅黑（simsun.ttc）、宋体等字体文件是否存在/usr/share/fonts/truetype中
转化的HTML中必须要把那种全屏遮蔽的div、悬浮窗之类的删掉，大概因为PDF渲染颜色的原因，不仅转化需要超长时间而且打开PDF卡的要死

随便看一看

看看 Life in Coding , ruby on rails

Rails中has_many等的原理

-Flyぁ梦- — Sat, 04 Oct 2014 15:42:56 +0000

刚接触rails的时候着实被has_many给惊到，这么厉害的功能，尤其是has_many的延迟加载，直到真正需要读取数据的时候才会进行SQL查询（person.posts.size，并不会执行select *到内存后再对Array执行size），但是用普通的调试方法怎么看has_many的结果是一个Array，比如.class方法，然后就觉得很神奇。

看了源码之后，就了解has_many实现机制其实很简单，就是由一个代理类ActiveRecord::Associations::HasManyAssociation来实现的，真正的数据被封装在内部，真正需要用到数据的时候再去加载，这就是延迟加载；至于为什么看上去这么像Array或者说简直就是个Array是因为，HasManyAssociation算是一个白板类，删掉了从Object继承过来的大部分方法，包括.class方法，当你调用.class方法时就进入到了method_missing方法，然后就交给这个类内部的真正的数据结构Array去调用这个方法，自然表现出来就是一个Array了。所以要显示出这个类原来样貌，只要随意调用一个不存在的函数，比如person.posts.abcdefg()，就会提示HasManyAssociation没有这个方法了。

用法举例：

user.posts     // select * from

user.posts.size 或 user.posts.count  //select count(*) from

user.posts.length // select * from 后，再对Array取size；这个适用于需要先判断数量然后同时取数据（少量），省去count(*)这一条sql

user.posts << Post.new 或 user.posts.create // insert into ...

user.posts.clear 或 user.posts.destroy_all  // delete from ...

要尤其注意target的用法，因为HasOneAssociation本身就有target方法（用来获取Association对象本身），所以若对象本身又有target方法，则首先会调用Association对象的target方法。

class A
    has_one :relation, :class_name => 'B'
end

class B
    belong_to :target, :class_name => 'C'
end

a = A.find_by_id(1111)

a.relation => B的Association对象
p a.relation  =>    B（先调用Association.method_missing方法，转而调用B.inspect方法）

a.relation.target => 只是B对象
p a.relation.target     =>    B（直接调用B.inspect方法）

a.relation.target.target  =>  C的Association对象
p a.relation.target.target       =>    C

这里选择打印调试则会出现比较奇怪的现象（p a.relation和p a.relation.target的结果是一样的，是因为p和puts调试，调用inpect和to_s方法，都是Association没有的，会通过method_missing转为调用对象本身的方法）

随便看一看

看看 ruby on rails

2015-08-12 -- Liunx下搭建Rails和Nginx环境
2015-04-09 -- JSON中出现解析错误的原因之一：不可打印字符
2014-12-21 -- Ruby字符串的编码
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-07-28 -- 简析Rails：active_support 2.3.5

记C#和Excel开发

-Flyぁ梦- — Wed, 10 Sep 2014 07:31:54 +0000

需要一个windows环境下的工具，能够读写Excel。这个Excel比较复杂，内嵌VB脚本，写Excel的时候必须得保留这些原有的脚本数据。

介绍下这个VB脚本，就是给每一行数据提供下拉框进行一些备用数据的选择，比如打标签。这个下拉框并不是Excel提供的控件（控件绑定于具体的Cell或者坐标很麻烦），而是用弹窗实现的，全局共享一个弹窗数据源。这是一段在Excel文件中的VB代码。

最初开始用Python，靠xlrd和xlwt模块进行读写，读的确没什么问题也挺方便，但是写就有点纠结了，xlwt不能写已经存在的excel文件而是需要新创建一个文件然后开始写入然后替换原有文件，如果Excel文件中有设置好的一些格式、控件、脚本的话，就都没了。然后Python最麻烦的当然就是windows下是没有预装Python的，这个工具给别人使用还要带一个Python环境真是麻烦，然后文件就很多包括.py、双击运行的.bat等。

然后想到的就是能够在win环境下良好支持的C#，本科的时候还是学过C#的有那么一点点基础而且毕竟和Java比较像。C#提供的操纵Excel功能的确比较强大，但是没这么好用，很容易报异常需要耐心调试。但是能够编译成.exe，在win环境下运行起来到底方便。

VS创建项目时，会提示选择.Net Framework版本，尽量选择4.0（win7自带）或者更低的，以更好的跨平台；一开始用了默认的4.5（大概是安装VS时候给自动装上的，编译出来在某些win7环境中会报错）

md5的方法：最简单的是用Web模块里的那个方法，但是这个Web模块似乎不太跨平台；网上方法很多，但是算出来的答案居然都不太一样！选个靠谱的不容易...

写代码的时候遇到过的几个坑

xlsApp.Visible = false; （不然每次执行都会打开Excel再关闭）

xlsApp.DisplayAlerts = false; （不然保存的时候会各种提示确认比较烦）

filePath = filePath.Replace('/', '\\');   xlsBook.SaveAs ...（文件路径用 / 就会报异常）

xlsBook.Close(false, Type.Missing, Type.Missing); （没有这句话，程序执行完后Excel的进程就会留在内存中...执行多次就一堆死进程...）

微软的代码风格也就算了，操纵Excel的各种API的命令和使用方法，真是无法直视

看看 .Net , C++ , Excel , Python

2014-07-07 -- ruby on rails
2011-10-20 -- ZOJ起步 100AC

看看 Life in Coding

2016-09-09 -- jabber和XMPP简述原理
2015-01-07 -- 防止数据库数据重复的几种方法
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2011-06-11 -- 2011-6-9 Google Doodle之电子琴
2011-03-10 -- 学计算机的尼玛伤不起啊！！！！！！

简析Rails：active_support 2.3.5

-Flyぁ梦- — Mon, 28 Jul 2014 13:02:26 +0000

项目中用到Rails2.3.5，就以此版本研究。和Rails本身相关的，大概有actionmailer（发邮件相关）、actionpack（HTTP和controller相关）、activerecord（ORM框架）、activeresource、activesupport（基础扩展库）。

activesupport库算是一个基础扩展API库，主要分为两部分，一部分是可供选择的OOP形式的类和API，还有一部分是以Module形式存在的API以打开类的方式直接扩展进入Ruby源代码（即原有基础类）中。打开类扩展的API有一些应该被纳入Rurby源码，写惯Rails代码的脱离了activesupport再去写Ruby估计很不适应。

在po主本机上，库位于：`xx\Ruby193\lib\ruby\gems\1.9.1\gems\activesupport-2.3.5\lib`

activesupport库的结构

activesupport.rb 已被废弃，require此文件会转require active_support.rb文件，并产生一个warning
active_support.rb 用来导入activesupport库中所有类和模块
active_support目录
- core_ext目录基础扩展库
  - 具体模块目录
  - 模块目录导入文件
  - 简单独立模块.rb
- vendor目录
  - 具体模块目录
- 具体功能目录…（如json）
- 功能导入文件.rb（如json.rb），用以导入同名具体功能目录下所有的文件
- 其他功能独立文件.rb（如base64.rb、ordered_hash.rb）

activesupport导入流程

require active_support.rb
用autoload方法导入大部分独立类库和目录类库导入文件
1. 目录类库导入文件，导入相应的目录下的文件，并作一些初始化工作
require active_support/{vendor, core_ext, dependencies, json}
1. 导入core_ext下所有rb文件，当rb文件为导入文件时，再导入core_ext下的目录文件
2. 使用gem安装导入vender下的一些类库（builder、memcache-client、tzinfo、i18n）

active_support库的分层加载机制值得模仿学习，每一个子目录都有对应的一个导入rb文件。

activesupport的core_ext基础库扩展

按照功能类别排序划分。下面每个子目录下大概有2-10几个rb文件，都是对同一个模块或者类进行扩展，按照功能和意义的不同划分不同的类管理API。

array目录
enumerable.rb
hash目录
range目录
string目录
proc.rb
symbol.rb

Class、Object、Module、Kernel

对Class的扩展：

cattr_accessor :xxx，用来定义@@类变量，同时定义类方法和实例方法
read_inheritable_attribute、write_inheritable_attribute：用名为@inheritable_attributes的实例变量保存了一个hash，用来存储
class_inheritable_accessor :xxx，用类实例变量存储hash，实现同上
subclasses、remove_subclasses、remove_class

对Object的扩展：

blank?和present?
acts_like?(duck)：与具体模块中acts_like_duck?结合使用
with_options：调用可以传入hash键值的函数时，统一加入指定的键值对
tap：在调用链中用来遍历，本身什么也不干，一般用来输出调试
instance_values：将实例变量设置成hash返回
instance_variable_defined?：是否定义了某个实例变量
subclasses_of、extended_by、extend_with_included_modules_from：继承相关的API

对Module的扩展：

attr_internal :xxx和attr_internal_accessor :xxx，基本和attr_accessor一致，以@_xxx命名格式存储，不容易引起冲突（尤其在继承中）
mattr_accessor :xxx，定义@@xxx的读写方法。和Class的cattr_accessor的区别是，mattr用在module中，cattr用在Class中，混用可能导致错误
alias_method_chain(target, feature)：定义target_without_feature和target_with_feature函数，并将target alias 为feature。此函数在Rails源码中被用到很多
alias_attribute(new_name, old_name)：复制一套属性访问方法
included_in_classes：被included的Class集合

对Kernel的扩展：

daemonize：调用Process.daemon

Array、Enumerable、Hash、Range、String

对Array的扩展：

访问元素用的API（access.rb）：from(pos)、to(pos)、second、third、forty_two（这个API有点意思）
格式化输出的API（conversions.rb）：to_param、to_query、to_formatted_s代替to_s、to_xml
extract_options!（extract_options.rb）：取出函数参数中位于最后的hash
将元素分组的API（grouping.rb）：in_groups_of(num)每个组有num个元素、in_groups(num)分成num个组、split(value)按元素分组
rand(random_access.rb)：随机访问元素
wrap(wrapper.rb)：将其他对象包装成Array

对Enumerable的扩展：

index_by：用元素的某个属性建立hash，最常见就是用id作为键
group_by：用元素的某个属性建立元素为array的hash
each_with_object：Ruby1.9中自带的方法
none?
sum?
many?

from、to、index_by、group_by这几个函数太常用了，一开始不知道还自己写了一套通用的实现。

对Hash的扩展：

格式化输入和输出的API(conversions.rb)：Hash.from_xml、to_xml、to_query
deep_merge和deep_merge!(deep_merge.rb)：当同一key两value都是Hash时递归式merge键值对
diff（diff.rb）：两个hash之间不同的键值对
except和except!（except.rb）：去除指定的key
slice和slice!（slice.rb）：只留下指定的key
with_indifferent_access方法和HashWithIndifferentAccess类（indifferent_access.rb）：字符串和符号键无区别对待
reverse_merge和reverse_merge!（reverse_merge.rb）：反方向merge
格式化key的API（keys.rb）：stringify_keys、stringify_keys!和symbolize_keys、symbolize_keys!，前两个将所有key转化为字符串形式，后两个转为为符号

对String的扩展：

文件太多，就列举一下API。

访问类API：at(pos)用来解决Ruby1.8中返回int值的结构、from(pos)、to(pos)、first、last
转化为时间类API：to_time(form = :utc)、to_date、to_datetime
squish和squish!：去掉字符串前后空格，并将内部的连续空格合并为1个
格式化字符串类API：使用外部的Inflector类实现
- pluralize：复数形式
- singularize：单数形式
- camelize：驼峰形式
- underscore：下划线形式
- dasherize：中划线形式
- demodulize：去除模块名之前的前导模块，得到最后的模块名
- titleize：首字母大写
- humanize：最佳阅读形式
- classify：类名形式
each_char：遍历每个字符
Ruby1.8字节串到字符串的转化API：mb_chars、is_utf8?
starts_with?和end_with?
升级+和<<、add_with_safety、html_safe?：将+和<<升级用add_with_safety实现

对Range的扩展：

include?扩展即include_with_range?（include_range.rb）：升级为同时支持Range对象的include?判断
overlaps?（overlaps.rb）：判断是否覆盖

Proc和Symbol

对Proc的扩展：只有一个bind函数，讲Proc绑定到一个object作为一个实例方法

对Symbol的扩展：只有一个to_proc函数（即对&操作符的处理），配合起来index_by、group_by方法不要太给力。

hash_by_id = list.index_by(&:id) hash_group_by_type = list.group_by(&:type)

Integer、Numeric、Float

很大程度配合Date、Time、DateTime模块。

对Integer的扩展：

even?、odd?
ordinalize：给数字末尾加上序号串，1=>1st，102=>102nd
months、years：配合日期的加减或者直接打印，返回值是Duration对象

对Numeric的扩展：

bytes、kilobytes、megabytes、gigabytes、terabytes、petabytes、exabytes和所有的单数形式，节省计算各个1024
seconds、minutes、hours、days、weeks、fortnights：同Integer的months
ago(time)和untile(time)、since(time)和from_now(time)：前者time – self，后者time + self

对Float的扩展：

round_with_precision(precision = nil)：按照精度四舍五入
years、months

Date、Time和DateTime

要结合core_ext同目录下的duration.rb中的Duration类实现。给这三个类增加的API都比较类似，就大致举例一些API和用法好了。

以下方法基本为Date和Time类共享：

升级+和-为可以计算Duration类型的方法plus_with_duration(other)、minus_with_duration(other)
yesterday、tomorrow
past?、today?、future?
beginning_of_day、midnight、at_midnight、end_of_day、beginning_of_week、end_of_week、beginning_of_month、end_of_month、beginning_of_quarter、end_of_quarter、beginning_of_year、end_of_year
months_ago、months_since、years_ago、years_since
last_year、next_year、last_month、next_month、next_week
to_s(:db)：date对象直接生成%Y-%m-d形式，time对象生成%Y-%m-%d %H:%M:%S

对Time加上时区的扩展：都是静态函数

zone的读写
zone_default的读写
use_zone(time_zone)：修改时区
current

其他

activesupport的vendor

现在只有builder、i18n、tzinfo、memcache-client四个模块

activesupport的可选功能库

按照个人觉得有用度排序，有些感觉没啥用的和暂时看不懂得没有列出来

ordered_hash.rb和ordered_options.rb：保持插入顺序的Hash；OrderedOptions可以用hash.xxx = ‘xxx’的方式存储键值对（method_missing实现）
duration.rb：实现1.month.ago这样的时间跨度，用于对基础库Date和Time的扩展
callbacks.rb：define_callbacks :before_save, :after_save这样的钩子方法
rescuable.rb：捕获所有指定类型的异常，做统一处理
time_with_zone.rb：对Time类扩展时区功能
base64.rb：加密、解密
gzip.rb：用gzip算法压缩和读取string
json目录
multibyte目录：对Ruby1.8支持Unicode
cache目录：定了好几种存储方式，
- drb_store
- file_store
- mem_cache_store
- memory_store，就是个Hash
- synchronized_memory_store，同步的memory_store
- compressed_mem_cache_store
locale目录
testing目录
values目录
xml_mini目录

其他学习到的地方

Ruby1.9+和Ruby1.8差别非常大，导致active_support代码中要各种判断Ruby版本
- 字符串用Unicode实现
- Hash用OrderedHash实现
- 加入了BaseObject作为白板类
Object的act_like?(xxx)方法和其他模块分别定义act_like_xxx?方法，配合实现类似Java的接口机制，一般单独写在behavior.rb文件的Behavior模块中

随便看一看

2010-09-25 -- 免研面试
2010-05-09 -- 母亲节，绍兴游
2011-04-18 -- 擦肩而过的上海交大
2010-08-10 -- 第一天加班
2015-04-07 -- 美丽樱花，“文明”武汉

看看 ruby on rails

2015-08-12 -- Liunx下搭建Rails和Nginx环境
2015-04-09 -- JSON中出现解析错误的原因之一：不可打印字符
2014-12-21 -- Ruby字符串的编码
2014-10-25 -- linux的timeout处理wkhtmltopdf进程超时
2014-10-04 -- Rails中has_many等的原理

-Flyぁ梦- » Life in Coding

64位Linux下Java进程堆外内存迷之64M问题

看看 linux , 内存 , 内存泄露

看看 Java

jabber和XMPP简述原理

随便看一看

看看 Life in Coding

Linux MySQL查询默认情况下不区分大小写

随便看一看

读java concurrency in practice

看看 同步 , 并发 , 锁

看看 Java , Life in reading

线程清理

随便看一看

看看 Java

FutureTask简单分析和用法

FutureTask的一个实用场景

FutureTask源码分析

随便看一看

看看 Java

Semaphore简单分析

看看 锁

看看 Java

CountDownLatch简单分析

使用例子

源码分析

看看 共享锁 , 锁

看看 Java

ReentrantReadWriteLock简单分析

Sync类

state值拆分

针对每个线程的读锁的HoldCounter

Sync类的子类，UnfairSync和FairSync

代码实现

写锁的实现

读锁的加锁实现

Sync.tryAcquireShared（此方法阻塞至acquire成功或者返回失败）

AQS.acquireShared

AQS.doAcquireShared

AQS.setHeadAndPropagate和AQS.doReleaseShared

读锁的解锁实现

Sync.tryReleaseShared（此方法阻塞至release成功，返回是否锁被释放）

读锁与写锁的实现区别

tryReadLock和tryWriteLock

看看 共享锁 , 并发 , 锁

看看 Java

可重入锁、ReentrantLock、AQS、Condition

可重入锁

synchronized锁和ReentrantLock

ReentrantLock与AbstractQueuedSynchronizer

AQS内部数据结构

AQS中Node的waitStatus（以下简称ws值）状态值

AQS中Node的nextWaiter节点

ReentrantLock中的Sync、NonfairSync、FairSync

AQS中对线程的park和unpark

ReentrantLock的代码实现

非公平锁的lock

公平锁的lock

unlock

AQS中Condition的实现

condition.await

condition.signal和condition.signalAll

看看 并发 , 锁

看看 Java

Tomcat监听shutdown释放数据库连接池

Tomcat的shutdown的事件监听

数据库连接池的关闭和释放

看看 Tomcat , 数据库 , 进程

看看 Java

Tomcat启用https服务

第一步，获取证书

第二步，部署https

第三步，http自动跳转到https

第三步，https的注意事项

看看 HTTPS , Tomcat , 安全 , 证书

看看 Java

Tomcat开启gzip压缩

随便看一看

看看 Java

Spring-MVC中的一些问题

看看同步 , 并发 , 锁

看看锁

看看共享锁 , 锁

看看共享锁 , 并发 , 锁

看看并发 , 锁

看看多线程

看看域名 , 备案 , 虚拟主机 , 阿里云

看看博客建站

看看同步 , 并发 , 数据库