kylin代码阅读

copy自   http://dirlt.com/kylin.html 。


1 kylin

kylin是baidu in-house的异步编程框架，提供CPU，Network以及Disk异步操作接口，并且内置许多常用编程组件包括定时器和内存池等。

相关材料

  • 异步编程_百度文库 : http://wenku.baidu.com/view/6fa262f67c1cfad6195fa74e.html
  • 三谈火车票系统_新浪轻博客 : http://qing.blog.sina.com.cn/tj/85c4105033000ab2.html
  • SEDA: An Architecture for Well-Conditioned, Scalable Internet Services http://www.eecs.harvard.edu/~mdw/papers/seda-sosp01.pdf
  • Why Threads Are a Bad Idea http://www.stanford.edu/class/cs240/readings/threads-bad-usenix96.pdf
导读：（我添加的）
线程库：CThreadPool  提供按任务多线程执行能力
内存管理：CTranBufPool， 内存管理能力，
内存管理的包装系列函数：BufHandle  系列
以下都是利用上面的基础资源构建
执行cpu任务操作包装类：ExecMan
磁盘（文件)任务类:DiskMan
网络交互任务类：NetworkMan，单独为poll增加了类Epoller   将这两个类封装以下，构成：Socket类
缺点：
1. 代码没有注释，简直没法读，而且没用用户文档，感觉不想让人用（这是未广泛运用的主要原因）
2. 对外开放的接口利用太麻烦，用的人不读源码根本不知道该怎么用
3. 有些变量起名太差，可读性不好
优点：
线程池、内存管理都有了，基本的cpu，文件、网络任务都包括了

总体评价：感觉像是一个练手作品（说这句话，太自大了，主要是我代码能力太差，没读太明白。：））

1.1 share

公共组件代码

1.1.1 atomic

最主要实现了atomic add/swap/cas三个操作。

[cpp]  view plain copy
  1. // return old value  
  2. static inline int atomic_add(volatile int *count, int add) {  
  3.     __asm__ __volatile__(  
  4.         "lock xadd %0, (%1);"  
  5.         : "=a"(add)  
  6.         : "r"(count), "a"(add)  
  7.         : "memory");  
  8.     return add;  
  9. }  
  10.   
  11. // return old value  
  12. static inline int atomic_swap(volatile void *lockword, int value) {  
  13.     __asm__ __volatile__(  
  14.         "lock xchg %0, (%1);"  
  15.         : "=a"(value)  
  16.         : "r"(lockword), "a"(value)  
  17.         : "memory");  
  18.     return value;  
  19. }  
  20.   
  21. // return old value  
  22. // 语义是这样的  
  23. // 如果*lockword==comperand,那么*lockword=exchange  
  24. // 否则不进行任何操作  
  25. // 返回原始的*lockword  
  26.   
  27. // 对于cmpxchg x y的语义是这样的  
  28. // 如果y==%%eax,那么x->y.否则不变。然后y(原始)->%%eax  
  29. static inline int atomic_comp_swap(volatile void *lockword,  
  30.                                    int exchange,  
  31.                                    int comperand)  
  32. {  
  33.     __asm__ __volatile__(  
  34.         "lock cmpxchg %1, (%2)"  
  35.         :"=a"(comperand)  
  36.         :"d"(exchange), "r"(lockword), "a"(comperand));  
  37.     return comperand;  
  38. }     

汇编语言可以参考内核汇编语言规则（转）

然后再上面封装了一系列原子操作。封装的一系列原子操作还是比较好理解的。


[cpp]  view plain copy
  1. #define AtomicGetValue(x)    (atomic_comp_swap(&(x), 0, 0))  
  2. #define AtomicSetValue(x, v)    (atomic_swap(&(x), (v)))  
  3. #define AtomicSetValueIf(x, v, ifn)(atomic_comp_swap(&(x), (v), ifn))  
  4. #define AtomicDec(c)    (atomic_add(&(c), -1) - 1)  
  5. #define AtomicInc(c)    (atomic_add(&(c), 1) + 1)  

1.1.2 spinlock

spinlock直接使用atomic提供的原子操作来实现，理解起来倒不是很麻烦

[cpp]  view plain copy
  1. static inline void spin_lock(volatile int *lock) {  
  2.     int l;  
  3.     int i = 10;  
  4.     int id = thread_getid();  
  5.     //l==0的话说明原来lock==0然后被置为id  
  6.     //l==id的话说明原来lock==id那么就不必在进行加锁操作  
  7.     for (l=atomic_comp_swap(lock, id, 0);  
  8.          l!=0 && l!=id;  
  9.          l=atomic_comp_swap(lock, id, 0)  
  10.          ) {  
  11.         if (i --) {  
  12.             nop();  
  13.         }  
  14.         else {  
  15.             // 进行10次nop之后如果没有得到锁的话  
  16.             // 那么就直接relinquish CPU  
  17.             // #define thread_yield sched_yield  
  18.             i = 10;  
  19.             thread_yield();  
  20.         }  
  21.     }  
  22. }  
  23.   
  24. // 返回值可以知道之前lock是否锁在自己这里  
  25. // 如果为false的话表示自己并没有锁  
  26. static inline bool spin_unlock(volatile int *lock) {  
  27.     int id = thread_getid();  
  28.     return id == atomic_comp_swap(lock, 0, id);  
  29. }  
  30.   
  31. static inline bool spin_trylock(volatile int *lock) {  
  32.     int id = thread_getid();  
  33.     int owner = atomic_comp_swap(lock, id, 0);  
  34.     return (owner==0 || owner==id);  
  35. }  


在spinlock.h下面有一个token实现。token语义非常简单，如果token==0的话那么这个令牌没有被任何人获得， 如果token!=0的话，那么令牌被token标记的对象获取了。token可以是pid,也可以是tid.

[cpp]  view plain copy
  1. static inline int token_acquire(volatile int *token, int id) {  
  2.     return atomic_comp_swap(token, id, 0);  
  3. }  
  4.   
  5. static inline int token_release(volatile int *token, int id) {  
  6.     return atomic_comp_swap(token, 0, id);  
  7. }  
  8.   
  9. static inline int token_transfer(volatile int *token, int oldid, int newid) {  
  10.     return atomic_comp_swap(token, newid, oldid);  
  11. }  
  12.   
  13. static inline int token_set(volatile int *token, int id) {  
  14.     return atomic_comp_swap(token, id, *token);  
  15. }  

1.1.3 cycle

提供开销更小的计时器，使用读取CPU的time stamp counter.这个内容表示自计算机启动以来的CPU运行周期。

[cpp]  view plain copy
  1. static inline uint64 rdtsc() {  
  2.     unsigned int lo, hi;  
  3.     /* We cannot use "=A", since this would use %rax on x86_64 */  
  4.     __asm__ __volatile__ (  
  5.         "rdtsc"  
  6.         : "=a" (lo), "=d" (hi));  
  7.     return (uint64)hi << 32 | lo;  
  8. }  

得到周期之后我们必须转换称为时间(s)。周期转换称为时间就是除CPU的主频。得到CPU主频的话没有什么特别好的办法， 一种简单的方法是通过等待1s然后得到tsc差。对于Linux操作系统的话可以通过读取proc文件系统获得

[[email protected]]$ cat /proc/cpuinfo
processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 12
model name      : Intel(R) Xeon(R) CPU           E5620  @ 2.40GHz
stepping        : 2
cpu MHz         : 2400.186
cache size      : 256 KB
physical id     : 0
siblings        : 16
core id         : 0
cpu cores       : 16
fpu             : yes
fpu_exception   : yes
cpuid level     : 11
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl est tm2 cx16 xtpr
bogomips        : 4803.76
clflush size    : 64
cache_alignment : 64
address sizes   : 40 bits physical, 48 bits virtual
power management:

1.1.4 support

从这里面我们可以学习到如何进行系统调用，阅读一下<asm/unistd.h>可以找到系统调用号，然后使用syscall来发起。

[cpp]  view plain copy
  1. #include <unistd.h>  
  2. #include <sys/syscall.h>  
  3. #include <cstdio>  
  4. int main() {  
  5.     printf("%lu\n",syscall(__NR_gettid));  
  6.     return 0;  
  7. }  

1.1.5 futex

关于futex的话可以看看下面这些链接

  • http://en.wikipedia.org/wiki/Futex
  • http://linux.die.net/man/2/futex
  • http://blog.csdn.net/Javadino/article/details/2891385
  • http://blog.csdn.net/Javadino/article/details/2891388
  • http://blog.csdn.net/Javadino/article/details/2891399
  • http://people.redhat.com/drepper/futex.pdf

尤其是最后一篇文章可以好好看看，讲到了关于如何使用futex.futex使用需要用户态和内核态的配合，用户态处理一些uncontented case, 而对于contented case的话交给内核态处理。在实际应用上发现大部分情况都是uncontented case都可以在用户态解决而不用陷入内核态。 如果想要深入了解的话，看看pthread里面同步组件的实现。

这里我们简单地介绍一下kylin里面使用futex实现的功能，先看看futex结构

[cpp]  view plain copy
  1. struct futex {  
  2.     volatile int lock; // futex shared address  
  3.     volatile int count;  
  4. };  

1.1.5.1 sema  （不明白为啥不用系统的Semaphore实现？）

可以认为是操作系统里面的PV实现.count就是资源数目，lock始终==0.理解起来并不会很麻烦。

[cpp]  view plain copy
  1. static inline int futex_sema_down(struct futex* pf, struct timespec* timeout, bool interruptable) {  
  2.     // 首先在用户态尝试取资源  
  3.     // 如果n>0的话，说明资源OK,那么就不需要陷入内核态进行wait.  
  4.     int n = atomic_add(&pf->count, -1);  
  5.     if (n <= 0) {  
  6.   retry:  
  7.         if (0 == sys_futex(&pf->lock, FUTEX_WAIT, 0, timeout)) {  
  8.             return 0;  
  9.         }  
  10.         switch (errno) {  
  11.             case ETIMEDOUT:  
  12.                 atomic_add(&pf->count, 1);  
  13.                 return ETIMEDOUT;  
  14.             case EINTR:  
  15.                 if (!interruptable)  
  16.                     goto retry;  
  17.                 atomic_add(&pf->count, 1);  
  18.                 return EINTR;  
  19.             default:  
  20.                 RaiseError(IMPOSSIBLE__Can_not_lock_in_futex_sema_down);  
  21.         }  
  22.     }  
  23.     return 0;  
  24. }  
  25. static inline int futex_sema_up(struct futex* pf) {  
  26.     int retry;  
  27.     // 首先在用户态释放资源  
  28.     // 如果n<0的话，说明存在等待资源的waiters,我们必须陷入内核态wakeup.  
  29.     int n = atomic_add(&pf->count, 1);  
  30.     if (n < 0) {  
  31.         retry = 10;  
  32.         // 这个地方写得非常仔细需要重试  
  33.         while (1 != (n=sys_futex(&pf->lock, FUTEX_WAKE, 1, NULL))) {  
  34.             /* it means the downer decreases the count but not yet start waiting 
  35.              *   --- may be interrupted near the retry label in the above function; 
  36.              * so we have to wait and retry. 
  37.              */  
  38.             if (retry --) {  
  39.                 nop();  
  40.             }  
  41.             else {  
  42.                 retry = 10;  
  43.                 thread_yield();  
  44.             }  
  45.         }  
  46.         return n;  
  47.     }  
  48.     return 0;  
  49. }  

1.1.5.2 cond（为啥不用pthread_cond?)

这里cond和pthread_cond是有差别的，这里的cond没有和任何mutex相关。kylin这里认为count==0的时候，那么condition才被满足。

[cpp]  view plain copy
  1. static inline int futex_cond_wait(struct futex* pf, struct timespec* timeout, bool interruptable) {  
  2.     /* I dont know whether it is a bug of linux kernel. 
  3.      * Sometimes, sys_futex(.., FUTEX_WAIT, ..) returns 0, but the condition is not satisfied. 
  4.      * So we have to check the condition again after return. 
  5.      */  
  6.     while (0 < AtomicGetValue(pf->count)) {  
  7.         sys_futex(&pf->lock, FUTEX_WAIT, 0, timeout);  
  8.         switch (errno) {  
  9.             case ETIMEDOUT:  
  10.                 return ETIMEDOUT;  
  11.             case EINTR:  
  12.                 if (interruptable) {  
  13.                     return EINTR;  
  14.                 }  
  15.             default:  
  16.                 break;  
  17.         }  
  18.     }  
  19.     return 0;  
  20. }  
  21.   
  22. static inline int futex_cond_signal(struct futex* pf) {  
  23.     int n = atomic_add(&pf->count, -1);  
  24.     if (1 == n) {  
  25.         pf->lock = 1; // 一旦触发之后，那么就不能够再进行wait了。  
  26.         mfence_c();  
  27.         return sys_futex(&pf->lock, FUTEX_WAKE, 65535, NULL);// I hope 65535 is enough to wake up all  
  28.     }  
  29.     return 0;  
  30. }  

1.1.5.3 event

这里的event名字取得也相当的奇怪。这里count实际上有两个状态，>=0以及<0(LARGE_ENOUGH_NEGATIVE).对于count>=0的状态时候， 可以认为当前是没有signaled的需要wait，如果count为<0(LARGE_ENOUGH_NEGATIVE)的时候是有signal的状态的不需要wait。

[cpp]  view plain copy
  1. static inline int futex_event_wait(struct futex* pf, struct timespec* timeout, bool interruptable) {  
  2.     // 如果不是signaled状态的话  
  3.     int n = atomic_add(&pf->count, 1);  
  4.     if (0 <= n) {  
  5.   retry:  
  6.         if (0 == sys_futex(&pf->lock, FUTEX_WAIT, 0, timeout))  
  7.             return 0;  
  8.   
  9.         switch (errno) {  
  10.             case ETIMEDOUT:  
  11.                 atomic_add(&pf->count, -1);  
  12.                 return ETIMEDOUT;  
  13.             case EINTR:  
  14.                 if (!interruptable)  
  15.                     goto retry;  
  16.                 atomic_add(&pf->count, -1);  
  17.                 return EINTR;  
  18.             default:  
  19.                 RaiseError(IMPOSSIBLE__Can_not_lock_in_futex_sema_down);  
  20.         }  
  21.     }  
  22.     else {  // else signaled  
  23.         AtomicSetValue(pf->count, LARGE_ENOUGH_NEGATIVE);  
  24.     }  
  25.     return 0;  
  26. }  
  27.   
  28. static inline int futex_event_signal(struct futex* pf, bool reset) {  
  29.     int m, n, retry;  
  30.     // 看看当前是否signaled  
  31.     // 如果没有signal的话，那么需要wakeup这些waiters.  
  32.     n = AtomicSetValue(pf->count, reset ? 0 : LARGE_ENOUGH_NEGATIVE);  
  33.     if (0 < n) {  
  34.         retry = 10;  
  35.         m = n;  
  36.         do {  
  37.             n -= sys_futex(&pf->lock, FUTEX_WAKE, n, NULL);  
  38.             if (0 == n)  
  39.                 return m;  
  40.             if (retry --) {  
  41.                 nop();  
  42.             }  
  43.             else {  
  44.                 retry = 10;  
  45.                 thread_yield();  
  46.             }  
  47.         } while (1);  
  48.     }  
  49.     return 0;  
  50. }  
  51.   
  52. static inline void futex_event_reset(struct futex* pf) {  
  53.     int n, retry = 10;  
  54.     do {  
  55.         n = AtomicSetValueIf(pf->count, 0, LARGE_ENOUGH_NEGATIVE);  
  56.         if (0<=n || LARGE_ENOUGH_NEGATIVE==n) {  
  57.             return;  
  58.         }  
  59.         if (retry --) {  
  60.             nop();  
  61.         }  
  62.         else {  
  63.             retry = 10;  
  64.             thread_yield();  
  65.         }  
  66.     } while (1);  
  67. }  

1.2 kylin

异步框架代码

1.2.1 Async

kylin对于用户来说首先需要了解的概念就在Async.h文件里面，主要是下面两个类

[cpp]  view plain copy
  1. typedef void (*JOB_PROC)(Job*);  
  2.   
  3. // 对于Job这个内容我们稍后在ThreadPool部分会有详细分析  
  4. struct Job {  
  5.     DLINK link; // 使用link的话可以将Job在JobQ中串联起来可以很方便地取消  
  6.     JOB_PROC fProc; //线程池里面包含JobQ,每取一个Job出来之后就执行fProc.  
  7. };  
  8.   
  9. class CAsyncClient;  
  10. struct AsyncContext : Job {  
  11.     APF_ERROR nErrCode; // 发起调用之后返回的error_code  
  12.     int nAction; // 发起什么调用  
  13.     CAsyncClient *pClient; // 应该使用什么client来处理  
  14. };  
  15.   
  16. class CAsyncClient  
  17. {  
  18. protected:  
  19.     // m_nId仅仅是一个编号，每次创建一个AsyncClient都会全局+1  
  20.     // m_nHostId非常重要，使用这个可以将Job控制丢到哪个线程执行  
  21.     int m_nId, m_nHostId;  
  22.     volatile int m_nRef;  
  23.     CAsyncClient(CAsyncClient* pHost);  
  24.     CAsyncClient();  
  25.     virtual ~CAsyncClient();  
  26. public:  
  27.     int GetId() const { return m_nId; }  
  28.     int GetAsyncId() const { return m_nHostId; }  
  29.     int GetHostThreadId() const;  
  30.     bool IsInHostThread() const;  
  31.     void SetHost(CAsyncClient* pHost);  
  32.     virtual int AddRef() {  
  33.         return AtomicInc(m_nRef);  
  34.     }  
  35.     virtual int Release() {  
  36.         return AtomicDec(m_nRef);  
  37.     }  
  38.     virtual int GetRef() {  
  39.         return AtomicGetValue(m_nRef);  
  40.     }  
  41.     virtual void OnCompletion(AsyncContext* pCtx) = 0; // 用户需要重写这个过程  
  42. };  

对于用户来说使用过程大致是这样的：

  • 创建一个CAsyncClient client实例.当然是我们自己需要继承CAsyncClient重写自己的类。
  • 创建一个AsyncContext ctx(或者是集成AsyncContext).然后将ctx和client绑定。
  • 发起调用op，传入这个ctx，为了方便理解包装成为Task(op,ctx)放入线程池。可能会设置nAction字段。
  • 线程池取出Task,结合ctx调用op.将op返回值放入APF_ERROR里面。
  • 然后根据ctx关联的client,调用client的OnCompletion方法。
  • 调用OnCompletion方法的话会根据ctx里面的标记，可以直接在工作线程调用，也可以丢入CPU线程调用。

可以看到在实现时候，最好一个client就绑定几个相关的ctx最方便了。这里有一个地方需要特别关注就是引用计数。因为C++本身没有GC实现，所以我们必须自己来管理内存分配和释放。 因为client可以一次多个调用，而在OnCompletion里面根本不知道谁先完成谁后完成，也就不能够确定释放责任了。通过引用计数可以很好地解决这个问题。 如果我们直接继承CAsyncClient的话，内部是有引用计数实现的，非常方便我们只需要如何适当地使用就OK了。关于如何适当使用，谢谢sunxiao同学在这里的建议。

  • 一旦发起一次异步调用，那么首先AddRef().当然需要确保这个调用内部没有帮助我们AddRef.
  • 我们不需要显示地DecRef(),因为这个事情在线程池fProc里面调用了Release.

1.2.2 ThreadPool

1.2.2.1 Overview

线程池很简单，取出一个Job出来执行就多了。但是为了更好地理解kylin有必要看看线程池接口/实现。

[cpp]  view plain copy
  1. typedef void (*THREAD_INIT_PROC)(int type, int id); // id表示这个线程的逻辑编号  
  2.   
  3. class CThreadPool  
  4. {  
  5.     bool m_bShareQ; // 是否所有线程共享一个Q  
  6.     int m_nWorkers, m_nMaxWorkers; // 当前线程数和最大线程数  
  7.     volatile int m_nJobs; // 当前有多少个Jobs  
  8.     thread_t *m_hWorkerThreads; // 每个线程的thread结构  
  9.     WorkerContext *m_pContexts; // 每个线程的context  
  10.     int m_nType; // 什么类型线程池,TT_EXEC,TT_NETWORK,TT_DISK  
  11.     THREAD_INIT_PROC m_fInit; // 线程初始化回调函数  
  12.   
  13.     int _AddWorker(int nAdd); // 增加多少个工作线程  
  14.     int _DelWorker(int nDel, bool bFinal); // 取消多少个工作线程  
  15.   public:  
  16.     CThreadPool(int type, int nMaxWorkers, bool bShareQ);  
  17.     virtual ~CThreadPool();  
  18.     int Start(int nWorkers, THREAD_INIT_PROC fInit=NULL);  
  19.     void Stop();  
  20.     void QueueJob(Job* pJob, int nWhich);  
  21.     void QueueEmergentJob(Job* pJob, int nWhich);  
  22.     bool CancelJob(Job* pJob, int nWhich);  
  23. };  

对于线程池部分的话我们比较关心这么几件事情：

  • 如何增加删除线程的
  • 线程是如何进行工作的
  • 如何往线程里面增加取消任务
1.2.2.2 How Thread Works

了解线程是怎么工作的，可以看看线程执行的函数是怎么定义的

[cpp]  view plain copy
  1. static void*  
  2. WorkerProc(void* pData)  
  3. {  
  4.     WorkerContext* pCtx = (WorkerContext*)pData;  
  5.     JobQ* pJobQ = pCtx->pJobQ;  
  6.     Job* pJob;  
  7.   
  8.     TRACE4("%s worker#%d started...\n", ThreadType2Str(pCtx->type), pCtx->id);  
  9.     pCtx->thread_id = thread_getid();  
  10.     if (pCtx->fInit) { // 如果有初始化函数的话那么执行初始化函数  
  11.         pCtx->fInit(pCtx->type, pCtx->id);  
  12.     }  
  13.     while (1) {  
  14.         pJob = pJobQ->pop_front(); // 每次得到一个Job  
  15.         ASSERT_NOT_EQUAL((Job*)NULL, pJob);  
  16.         if (pJob->fProc != 0) { // 如果是普通Job的话那么是调用里面的Job::fProc过程  
  17.             pCtx->bDoing = true;  
  18.             pJob->fProc(pJob);  
  19.             pCtx->bDoing = false;  
  20.         }  
  21.         else { // 否则是控制Job，主要是用于结束线程使用的  
  22.             ControlJob* pCtl = (ControlJob*)pJob;  
  23.             if (!pCtl->fProc(pCtl, pCtx)) {  
  24.                 break;  
  25.             }  
  26.         }  
  27.     }  
  28.     TRACE4("%s worker#%d stopped.\n", ThreadType2Str(pCtx->type), pCtx->id);  
  29.     return NULL;  
  30. }  

普通的Job会在每个Man里面单独提到，我们看看控制Job是怎么定义的。在ThreadPool里面就有一个TermianationJob.

[cpp]  view plain copy
  1. struct TerminationJob : ControlJob {  
  2.     int id;  
  3. };  
  4.   
  5. static bool  
  6. TerminateWorker(ControlJob* pCtl, WorkerContext* pCtx)  
  7. {  
  8.     TerminationJob* pT = (TerminationJob*)pCtl;  
  9.     if (pT->id!=-1 && pT->id!=pCtx->id) { // 如果因为共享队列而没有让对应线程得到Job的话，那么重新放入这个Job.  
  10.         pCtx->pJobQ->push_back((Job*)pCtl); // should be shared queue  
  11.         thread_yield();                     // re-enqueue this job until the owner consumes it  
  12.         return true;  
  13.     }  
  14.     return false;  
  15. }  

通过这种方式来通知线程主动退出。理论上因为shared Queue可能会造成所有永远不会退出但是实际应该不会。

1.2.2.3 AddWorker & DelWorker

AddWorker非常简单

[cpp]  view plain copy
  1. int CThreadPool::_AddWorker(int nAdd)  
  2. {  
  3.     int i;  
  4.   
  5.     for (i=0; i<nAdd && m_nWorkers<m_nMaxWorkers; i++) {  
  6.         m_pContexts[m_nWorkers].fInit = m_fInit;  
  7.         if (m_pContexts[m_nWorkers].pJobQ == NULL) {  
  8.             m_pContexts[m_nWorkers].pJobQ = new JobQ; // 会为每一个WorkerContext分配一个JobQ.对于共享Q的话在初始化就分配好了。  
  9.         }  
  10.         if (0 != thread_create(&m_hWorkerThreads[m_nWorkers], NULL, WorkerProc, &m_pContexts[m_nWorkers])) { // 然后启动线程即可  
  11.             PERROR("thread_create");  
  12.             break;  
  13.         }  
  14.         m_nWorkers ++;  
  15.     }  
  16.     return i;  
  17. }  

DelWorker因为有ControlJob的辅助所以可以很好地解决，只需要在每个线程后面增加一个TerminationJob即可

[cpp]  view plain copy
  1. int CThreadPool::_DelWorker(int nDel, bool bFinal)  
  2. {  
  3.     TerminationJob *pTerminations = new TerminationJob[nDel];  
  4.     int i;  
  5.   
  6.     TRACE4("%s start terminating %d workers...\n", ThreadType2Str(m_nType), nDel);  
  7.     for (i=0; i<nDel && m_nWorkers>0; i++) {  
  8.         m_nWorkers --;  
  9.         DLINK_INITIALIZE(&pTerminations[m_nWorkers].link);  
  10.         pTerminations[m_nWorkers].fZero = 0;  
  11.         pTerminations[m_nWorkers].fProc = TerminateWorker;  
  12.         pTerminations[m_nWorkers].id = bFinal ? -1 : m_nWorkers;  
  13.         m_pContexts[m_nWorkers].pJobQ->push_back((Job*)&pTerminations[m_nWorkers]);  
  14.     }  
  15.     for (int j=m_nWorkers; j<i+m_nWorkers; j++) {  
  16.         TRACE4("%s wait for worker #%d.\n", ThreadType2Str(m_nType), j);  
  17.         thread_join(m_hWorkerThreads[j], NULL);  
  18.     }  
  19.     TRACE4("%s end terminating workers.\n", ThreadType2Str(m_nType));  
  20.     delete[] pTerminations;  
  21.     return i;  
  22. }  

1.2.2.4 QueueJob & CancelJob

相对来说QueueJob也更加简单一些，直接投递到某个线程对应的WorkerContext里面即可。

[cpp]  view plain copy
  1. void QueueJob(Job* pJob, int nWhich) {  
  2.      int nJobs = atomic_add(&m_nJobs, 1);  
  3.     if (-1 == nWhich) {  
  4.         nWhich = nJobs % m_nWorkers;  
  5.     }  
  6.     atomic_add(&m_pContexts[nWhich].nJobs, 1);  
  7.     m_pContexts[nWhich].pJobQ->push_back(pJob);  
  8. }  

而CancelJob则是通过加锁替换这个Job来完成的，还是比较精巧的

[cpp]  view plain copy
  1. static void  
  2. DoNothing(Job* pJob)  
  3. {  
  4.     free(pJob);  
  5. }  
  6.   
  7. bool CThreadPool::CancelJob(Job* pJob, int nWhich)  
  8. {  
  9.     Job* p = ZeroAlloc<Job>(); // 分配一个Job,而DoNothing就是将其释放掉  
  10.     p->fProc = DoNothing;  
  11.     if (m_pContexts[nWhich].pJobQ->replace(pJob, p)) { // replace这个工作是一个加锁完成的  
  12.         return true;  
  13.     }  
  14.     free(p); // 如果没有Cancel的话那么返回失败但是也会释放掉内存  
  15.     return false;  
  16. }  

1.2.3 TranBuf

TranBuf.h CTranBufPool是一个内存分配器。对于很多系统来说，合理地使用资源是非常必要的。

作者linsd对于内存分配器看法是这样的：

要得到稳定的高吞吐，对内存的合理使用是必要条件。是否用Ring Buffer倒不一定，简单的buffer pool效果也差不多。另外，为了应付极限情况，还需要为buffer请求分级，当资源不足时优先给紧急请求。也可设定高低几条watermark，让各种复杂条件下的资源使用变得平顺。

了解一下真实系统里面定制化的内存分配器是非常有帮助的(相对应地来说 TCMalloc 是通用内存分配器).

1.2.3.1 Overview

首先看看CTranBufPool的数据结构，看看里面每个字段含义和作用.对于TranBuf来说的话内部 本质还是一个sample allocator，也是按照固定的BlockSize来进行分配的。构造函数可以看到水位线三个阈值都是0.

[cpp]  view plain copy
  1. class CTranBufPool : public CBufPoolV {  
  2.   struct Handle { // 每个BlockSize字节内存内存由一个Handle管理.  
  3.     DLINK link; // 分配出来之后多个Handle组成环形双向链表.  
  4.     char* pBuffer; // 一个BlockSize的内存.  
  5.     Handle* pRealHdl; // 真实Handler.这个会在后面解释.  
  6.     int nRef; // 引用计数.  
  7.     int nConsBuf; // 对于自己引用的pBuffer后面还有多少个连续内存.  
  8.   };  
  9.   typedef TLinkedList<Handle> FreeList; //  
  10.   typedef std::map<char*, Handle*> BufferMap; // buffer和Handle映射.  
  11.   
  12.   FreeList m_FreeList;  
  13.   BufferMap m_BufferMap;  
  14.   
  15.   // m_nBlockSize 每个sample object即BlockSize  
  16.   // m_nBufferSize 1次连续开辟多少字节.  
  17.   // m_nBlockBase log2(BlockSize)  
  18.   int m_nBlockSize, m_nBufferSize, m_nBlockBase;  
  19.   
  20.   // m_nAlloc 一次开辟多少个BlockSize.其中m_nBufferSize=nAlloc*m_nBlockSize  
  21.   // m_nMaxBuffers 最多分配多少个Blcok  
  22.   // m_nBuffers 当前分配了多少个Block  
  23.   // m_nWaterMarks 分为3个水位线  
  24.   int m_nAlloc, m_nMaxBuffers, m_nBuffers, m_nWaterMarks[3];  
  25.   
  26.   // m_nMin. 一开始至少分配m_nMin*nAlloc个Block  
  27.   // m_nMax 最多分配m_nMax*nAlloc哥block.其中m_nMaxBuffers=m_nMax*nAlloc.  
  28.   int m_nMin, m_nMax;  
  29. };  
  30.   
  31.   CTranBufPool(const char* name, int nCategory) : CBufPoolV(name, nCategory) {  
  32.     m_nBuffers = 0;  
  33.     m_nBlockSize = m_nBufferSize = m_nAlloc = m_nMaxBuffers = m_nMin = 0;  
  34.     m_nWaterMarks[0] = m_nWaterMarks[1] = m_nWaterMarks[2] = 0;  

可以看到TranBuf分配方式是每次分配nAlloc个Block(这个过程在后面叫做AllocOnce).每个Block是BlockSize字节. 然后至少分配m_nMin*nAlloc(首先调用m_nMin个AllocOnce过程),最多分配m_nMax*nAlloc个Block.每个内存 不够的话都会调用AllocOnce这个过程。

这里稍微解释一下RealHdl这个字段的意思。对于单个Block分配出来的内存块，RealHdl==this.但是如果是 连续跨越多个Block内存快的话，那么每个Block对应的Handle里面RealHdl对应的是首地址的Handle.这样做的好处就是， 如果希望对这个内存块增加或者是减少引用计数的话，只是指引到一个Handle，对里面字段修改引用计数。否则的话， 需要遍历每个Block对应的Handle修改引用技术。

1.2.3.2 Create

大部分Create代码都是在设置参数，最后调用m_nMin次AllocOnce来分配初始的内存块。

[cpp]  view plain copy
  1. bool Create(int nBlockSize, int nAlloc, int nMin, int nMax, double fRatio1, double fRatio2) {  
  2.   m_nUnitSize = nBlockSize;  
  3.   m_nBlockSize = nBlockSize;  
  4.   m_nBlockBase = Log_2(nBlockSize);  
  5.   if (-1 == m_nBlockBase) {  
  6.     TRACE0(<span class="org-string">"Fatal: invalid block size of %d\n"</span>, nBlockSize);  
  7.     return false;  
  8.   }  
  9.   m_nAlloc = nAlloc;  
  10.   m_nMaxBuffers = nMax * nAlloc;  
  11.   m_nBufferSize = m_nBlockSize * m_nAlloc;  
  12.   m_nBuffers = 0;  
  13.   m_nMax = nMax;  
  14.   m_nMin = nMin;  
  15.   if (0 != fRatio1 && 0 != fRatio2) {  
  16.     m_nWaterMarks[0] = (int)((double)m_nMaxBuffers * fRatio1);  
  17.     m_nWaterMarks[1] = (int)((double)m_nMaxBuffers * fRatio2);  
  18.     m_nWaterMarks[2] = m_nMaxBuffers - 1;  
  19.   }  
  20.   for (int i = 0; i < m_nMin; i++) {  
  21.     if (!AllocOnce()) // 注意这里没有必要回滚，每次成功都会记录状态，在Destroy里面会释放掉。  
  22.       return false;  
  23.   }  
  24.   return true;  
  25. }  

1.2.3.3 AllocOnce

之前说过AllocOnce是分配一个连续内存块，每个Block大小是m_nBlockSize,而个数是nAlloc. 同时还需要分配nAlloc个Handle.每个Handle管理一个Block.

[cpp]  view plain copy
  1. bool AllocOnce() {  
  2.   char* pBuffer = (char*)AlignAlloc(m_nBlockSize, m_nBufferSize);  // AlignAlloc是什么东西？
  3.   Handle* pHdl = (Handle*)ZeroAlloc(m_nAlloc * sizeof(Handle));  
  4.   if (pBuffer && pHdl) {  
  5.     m_BufferMap.insert(BufferMap::value_type(pBuffer, pHdl)); // 记录下这个连续块的内存地址和Handle地址.  
  6.     // 在Destroy时候有用.  
  7.     m_nBuffers += m_nAlloc;  
  8.     pBuffer += m_nBufferSize - m_nBlockSize;  
  9.     pHdl += m_nAlloc - 1;  
  10.   
  11.     for (int i = 0; i < m_nAlloc; i++) { // 然后将我所有的Block加入到链表里面去.  
  12.       pHdl->pBuffer = pBuffer;  
  13.       pHdl->nRef = 0;  
  14.       pHdl->nConsBuf = i + 1;  
  15.       pHdl->pRealHdl = pHdl;  
  16.       m_FreeList.push_back(pHdl); // 对于ConsBuf大的Handle放在链表最后.  
  17.       // 从后面内存分配策略就可以发现，对于分配连续Handle的话都是从最后开始的。  
  18.   
  19.       pBuffer -= m_nBlockSize;  
  20.       pHdl --;  
  21.     }  
  22.     return true;  
  23.   }  
  24.   if (pBuffer)  
  25.     free(pBuffer);  
  26.   if (pHdl)  
  27.     free(pHdl);  
  28.   return false;  
  29. }  

1.2.3.4 GetHandle

GetHandle是通过传入buffer首地址来确定管理这个buffer的Handle.但是注意不是RealHdl. 如果需要对这个内存做引用计数的话，应该是对RealHdl做引用计数。可以看看下面的AddRef实现。

[cpp]  view plain copy
  1. Handle* GetHandle(char* pBuffer) {  
  2.   BufferMap::iterator it = m_BufferMap.upper_bound(pBuffer);  
  3.   if (it != m_BufferMap.begin()) {  
  4.     it --;  
  5.   
  6.     char* pHead = it->first;  
  7.     ASSERT(pHead <= pBuffer);  
  8.     if (pBuffer < pHead + m_nBufferSize) {  
  9.       int n = (pBuffer - pHead) >> m_nBlockBase;  
  10.       Handle* pHdl = it->second + n;  
  11.       ASSERT(pHdl->pBuffer == pHead + (((uint32)n) << m_nBlockBase));  
  12.       return pHdl;  
  13.     }  
  14.   }  
  15.   return NULL;  
  16. }  

1.2.3.5 AddRef

对某块内存进行引用计数。并且强大的是这个内存地址不必是分配的首地址，可以是连续内存内部任意地址。

[cpp]  view plain copy
  1. int AddRef(char* p, bool bCheck = false) {  
  2.   Handle* pHdl = GetHandle(p);  
  3.   if (NULL == pHdl) {  
  4.     if (!bCheck) {  
  5.       return -1;  
  6.     }  
  7.     RaiseError(Invalid_Block);  
  8.   }  
  9.   
  10.   int n = ++ pHdl->pRealHdl->nRef;  
  11.   ASSERT(2 <= n);  
  12.   return n;  
  13. }  

1.2.3.6 Destroy

Destroy是将AllocOnce分配的内存和Handle全部回收。因为得到了所有分配内存和Handle的起始地址 保存在map里面所以释放并不麻烦.

[cpp]  view plain copy
  1. void Destroy() {  
  2.   m_FreeList.Init();  
  3.   m_nBuffers = 0; // 将分配计数清零.  
  4.   
  5.   BufferMap::iterator it;  
  6.   for (it = m_BufferMap.begin(); it != m_BufferMap.end(); it++) {  
  7.     free(it->first);  
  8.     free(it->second);  
  9.   }  
  10.   m_BufferMap.clear();  
  11. }  

1.2.3.7 Allocate

分配内存。可以从参数里面看出来语义是说分配多少个Block.nPriority参数是说使用哪个水位线。 如果超过水位线的话，那么会使用相应的策略来处理(打印日志)。

[cpp]  view plain copy
  1. // 从freelist里面分配一个block出来.  
  2. #define _ALLOC_TRAN_BUF(p, how)                     \  
  3.   p = m_FreeList.how();                           \  
  4.   ASSERT(DLINK_IS_STANDALONE(&p->link));          \  
  5.   ASSERT(0 == p->nRef);                           \  
  6.   ASSERT(p->pRealHdl == p);                       \  
  7.   p->nRef = 1  
  8.   
  9.   char* Allocate(uint32 nPriority, int count = 1) {  
  10.     int n;  
  11.     ASSERT(0 != count);  
  12.     // 会尝试分配两次。第一次不进行AllocOnce.如果第一次失败的话那么第二次会尝试。  
  13.     for (int i = 0; i < 2; i++) {  
  14.       n = (int)m_FreeList.size();  
  15.       // 如果当前分配内存大于water mark的话会打印日志，但是为了过快的打印这里控制了打印间隔  
  16.       // 从这里可以看到这个是非多线程的。从后面BufHandle使用来看确实是这样的。  
  17.       if (m_nBuffers - n > m_nWaterMarks[nPriority]) {  
  18.         if (nPriority != 0) {  
  19.           static time_t last = 0;  
  20.           time_t now = time(NULL);  
  21.           if (now - last >= 30) {   // avoid too frequent print  
  22.             int n1 = m_nMaxBuffers - m_nBuffers + n;  
  23.             int n2 = m_nMaxBuffers - m_nWaterMarks[nPriority];  
  24.             TRACE0(<span class="org-string">"Warning: available tran buf (#%d) touches watermark(#%d, %.f%%)\n"</span>,  
  25.                    n1, n2, (double)(n1 * 100) / m_nMaxBuffers);  
  26.             last = now;  
  27.           }  
  28.         }  
  29.         return NULL;  
  30.       }  
  31.       if (n >= count) {  // 如果free list里面内容>=count的话，但是有可能没有连续内存用来分配。  
  32.         Handle* pHdl, *pTmp;  
  33.         if (1 == count) { // 如果分配1个的话，那么直接从前面分配  
  34.           _ALLOC_TRAN_BUF(pHdl, pop_front);  
  35.           return pHdl->pBuffer;  
  36.         }  
  37.         // 否则会从后面分配，因为后面Consecutive Buffer的概率会更高。  
  38.         // Big block are formed by multiple consecutive blocks.  
  39.         // We try from the tail of free list, which brings higher probability.  
  40.         _ALLOC_TRAN_BUF(pHdl, pop_back);  
  41.         int i = 1;  
  42.         if (pHdl->nConsBuf >= count) { // 看看最后的Handle的consectutive number是否足够.  
  43.           for ( ; i < count; i++) { // 并且看看是否被占用(通过引用计数判断).这里没有细看链表的组织。  
  44.             pTmp = pHdl + i;  
  45.             UNLIKELY_IF (0 != pTmp->nRef) {  
  46.               break;  
  47.             }  
  48.             m_FreeList.remove(pTmp);  
  49.             DLINK_INSERT_PREV(&pHdl->link, &pTmp->link);  
  50.             pTmp->pRealHdl = pHdl;  
  51.             pTmp->nRef = 1;  
  52.           }  
  53.         }  
  54.         if (i == count) { // 如果分配OK的话,那么返回  
  55.           return pHdl->pBuffer;  
  56.         } else { // 否则的话那么需要进行回滚.  
  57.           for (int j = 0; j < i; j++) {  
  58.             pTmp = pHdl + j;  
  59.             DLINK_INITIALIZE(&pTmp->link);  
  60.             pTmp->pRealHdl = pTmp;  
  61.             pTmp->nRef = 0;  
  62.             m_FreeList.push_front(pTmp);  
  63.           }  
  64.         }  
  65.       }  
  66.       // 如果分配内存超限或者是AllocOnce分配失败的话，那么直接返回。  
  67.       if (m_nBuffers >= m_nMaxBuffers || !AllocOnce()) {  
  68.         return NULL;  
  69.       }  
  70.     }  
  71.     return NULL;  
  72.   }  

1.2.3.8 Free
[cpp]  view plain copy
  1. #ifdef  _DEBUG  
  2. #define _FREE_TRAN_BUF(p, how)                              \  
  3.   memset(p->pBuffer, 0xCC, m_nBlockSize);             \  
  4.   m_FreeList.how(p)  
  5. #else  
  6. #define _FREE_TRAN_BUF(p, how)                              \  
  7.   m_FreeList.how(p)  
  8. #endif  
  9.   
  10.   int Free(char* p, bool bCheck = false) {  
  11.     Handle* pHdl = GetHandle(p);  
  12.     if (NULL == pHdl) {  
  13.       if (bCheck) {  
  14.         RaiseError(Invalid_Block);  
  15.       }  
  16.       return -1;  
  17.     }  
  18.   
  19.     pHdl = pHdl->pRealHdl;  
  20.     int n = -- pHdl->nRef; // 修改引用计数。  
  21.     if (0 == n) {  
  22.       Handle* pTmp = dlink_get_prev(pHdl);  
  23.       if (pTmp == pHdl) { // 如果是一个Block的话.  
  24.         ASSERT_EQUAL(pHdl->pRealHdl, pHdl);  
  25.         ASSERT_EQUAL(0, pHdl->nRef);  
  26.         _FREE_TRAN_BUF(pHdl, push_front);  
  27.         return 0;  
  28.       }  
  29.       // here comes big block  
  30.       Handle* p = pHdl; // 我们知道这个Handle组织称为环形双向链表。  
  31.       // 同样按照AllocOnce的顺序，将consecutive number大的handle放在末尾.  
  32.       do {  
  33.         pHdl = pTmp;  
  34.         pTmp = dlink_get_prev(pTmp);  
  35.         ASSERT_EQUAL(1, pHdl->nRef);  
  36.         ASSERT_EQUAL(p, pHdl->pRealHdl);  
  37.         pHdl->pRealHdl = pHdl;  
  38.         pHdl->nRef = 0;  
  39.         DLINK_INITIALIZE(&pHdl->link);  
  40.         _FREE_TRAN_BUF(pHdl, push_back);  
  41.       } while (p != pTmp);  
  42.       ASSERT_EQUAL(p, p->pRealHdl);  
  43.       ASSERT_EQUAL(0, p->nRef);  
  44.       DLINK_INITIALIZE(&p->link);  
  45.       _FREE_TRAN_BUF(p, push_back);  
  46.       return 0;  
  47.     }  
  48.     return n;  
  49.   }  


1.2.4 BufHandle

如果说TranBuf是底层内存分配器的话，那BufHandle就是应用层的内存分配器。BufHandle底层是通过 两个TranBuf来进行分配的。BufHandle本质上是chained的形式，主要是为了节省mem copy以及适应 network IO app的。通过全局的BufHandlePool对象来分配内存。

1.2.4.1 OverView

首先我们看看BufHandle结构以及提供的API.

[cpp]  view plain copy
  1. struct BufHandle {  
  2.   BufHandle* _next; // 链式指针.  
  3.   char* pBuf; // 管理的内存.  
  4.   int nBufLen;      // available buffer length 可用长度  
  5.   int nDataLen;     // occupied data length 占用长度  
  6. };  
  7.   
  8. // 从[pHdl,pNext)这个区间上面回收nLen长度出来分配出去.  
  9. BufHandle* Reclaim(int nLen, BufHandle* pHdl, BufHandle* pNext);  
  10.   
  11. // 设置TranBuf的参数.这个应该在Kylin调用之前就设置好，如果打算使用BufHandle的话。  
  12. void SetTranBuf(int nSmallNum, int nBigNum,  
  13.                 int nSmallSize = 4096,  
  14.                 float fLowMark = 0.6f,  
  15.                 float fHighMark = 0.9f);  
  16.   
  17. // NOTICE(dirlt):这里如果不允许失败的话，那么就会直接抛出异常.  
  18. // inPool表示这个buf是否在pool里面如果是的话那么可以直接使用引用计数优化减少copy  
  19. // pBuf表示src内存地址,nLen表示src内存长度.pNext表示allocate handle之后next字段值.  
  20. // 如果不是inPool的话，那么从TranBufPool里面分配.  
  21. BufHandle* AllocateHdl(bool bInPool = false, char* pBuf = NULL,  
  22.                        int nLen = 0, BufHandle* pNext = NULL);  
  23. // 从TranBufPool里面分配允许失败.  
  24. BufHandle* AllocateHdlCanFail(int nSize = 0);  
  25. // 从big pool里面分配1个block.  
  26. BufHandle* AllocateBigHdl();  
  27. BufHandle* AllocateBigHdlCanFail();  
  28.   
  29. // 释放这个Handle.  
  30. void FreeHdl(BufHandle* pHdl);  
  31. // 链式释放[pHdl,pNext)的链式里面的空间.  
  32. void ChainFreeHdl(BufHandle* pHdl, BufHandle* pNext);  
  33. // 这个名字取得不太好听，本质来说就是进行Clone  
  34. // pnLen数据长度是多少.bCopyNonTranBuf表示如果不能够做引用计数的话，是否需要copy.  
  35. BufHandle* CloneHdlAndTerminate(BufHandle* pHdl, BufHandle* pNext,  
  36.                                 int* pnLen = NULL, bool bCopyNonTranBuf = true);  

1.2.4.2 SetTranBuf

首先我们先看看CBufHandlePool的结构然后在看这个API

[cpp]  view plain copy
  1. // 继承于TObjectPool对象池可以直接高效分配出BufHandle对象出来.  
  2. class CBufHandlePool : public TObjectPool<BufHandle> {  
  3.   volatile int m_lock; // 多线程安全.  
  4.   CTranBufPool m_TranBufPool; // tran buf pool  
  5.   CTranBufPool m_BigBufPool; // big buf pool  
  6. };  
  7.   
  8.   CBufHandlePool() : TObjectPool<BufHandle>("BufHandle", BUFPOOL_C2),  
  9.     m_TranBufPool("TranBuffer", BUFPOOL_C1),  
  10.     m_BigBufPool("BigBuffer", BUFPOOL_C1) {  
  11.     m_lock = 0;  
  12.     Create(1024, 1);  
  13.   
  14.     int nAlloc = s_nTranBuf;  
  15.     int nMax = 1;  
  16.     // 一次不要分配超过512M.但是为了保持内存总量允许nMax增大.  
  17.     while ((s_nBufSize / 1024) * nAlloc > 524288) { /* Max alloc: 512M */  
  18.       nAlloc >>= 1;  
  19.       nMax <<= 1;  
  20.     }  
  21.     // tranbuf设置参数.  
  22.     m_TranBufPool.Create(s_nBufSize, nAlloc, 1, nMax, s_fLowMark, s_fHighMark);  
  23.     // 可以看到big buf的block size非常大.并且watermark非常高.分配次数在[0,10]之间.  
  24.     m_BigBufPool.Create(SZ_BIG_BUF, s_nBigTranBuf, 0, 10, 0.9, 0.9);  
  25.   }  
  26.   
  27. // 单例模式.  
  28. static CBufHandlePool* s_pBufHandlePool = NULL;  
  29. static CBufHandlePool* GetBufHdlPool() {  
  30.   if (NULL != s_pBufHandlePool) {  
  31.     return s_pBufHandlePool;  
  32.   } else {  
  33.     LOCK_THIS_BLOCK;  
  34.     if (NULL == s_pBufHandlePool) {  
  35.       s_pBufHandlePool = new CBufHandlePool;  
  36.     }  
  37.     return s_pBufHandlePool;  
  38.   }  
  39. }  

然后来看看这些参数是来如何设置的.

[cpp]  view plain copy
  1. int s_nTranBuf = 1024;  
  2. int s_nBufSize = 4096;  
  3. int s_nBigTranBuf = 64;  
  4. float s_fLowMark = 0.6f;  
  5. float s_fHighMark = 0.9f;  
  6.   
  7. void SetTranBuf(int nSmallNum, int nBigNum, int nSmallSize, float fLowMark, float fHighMark) {  
  8.   LOCK_THIS_BLOCK;  
  9.   
  10.   s_nTranBuf = nSmallNum; // tran buf应该每次alloc多少个block.  
  11.   s_nBigTranBuf = nBigNum; // big tran buf每次应该allocate多少个block.  
  12.   s_nBufSize = nSmallSize; // tran buf的blocksize.  
  13.   s_fLowMark = fLowMark;  
  14.   s_fHighMark = fHighMark;  
  15. }  

1.2.4.3 DoAllocate

这个是底层确保一定分配成功API(如果失败抛异常).来看看实现.使用hang住当前操作等待其他线程归还内存.

[cpp]  view plain copy
  1. // 从什么pool里面进行分配，尝试多少次分配.  
  2. BufHandle* DoAllocate(CTranBufPool* pPool, int nRetry) {  
  3.   BufHandle* pHdl;  
  4.   
  5.   for (int i = 0; i < nRetry; i++) {  
  6.     LOCK;  
  7.     pHdl = TObjectPool<BufHandle>::Allocate(); // 首先从对象池里面分配BufHandle对象.  
  8.     pHdl->pBuf = pPool->Allocate(i > 0 ? 2 : 1); // 然后从tran buf pool里面分配.  
  9.     // 注意这里第一次按照water mark1来分配,之后按照water mark2来分配.  
  10.     if (NULL == pHdl->pBuf) { // 如果分配失败的话，那么返回对象池.  
  11.       TObjectPool<BufHandle>::Free(pHdl);  
  12.       pHdl = NULL;  
  13.     }  
  14.     UNLOCK;  
  15.     if (NULL != pHdl) // 如果成功直接返回.  
  16.       return pHdl;  
  17.     if (i > 1) {  
  18.       TRACE0(<span class="org-string">"No enough memory, sleep %d\n"</span>, i + 1);  
  19.     }  
  20.     sleep(1); // 否则会hang住等待释放.  
  21.   }  
  22.   RaiseError(TODO_NO_ENOUGH_MEMORY); // 如果没有分配成功那么就会抛出异常.  
  23.   return NULL;  
  24. }  

1.2.4.4 DoAllocateCanFail

底层不一定保证分配成功，可能返回NULL表示失败.只是尝试一次分配.

[cpp]  view plain copy
  1. BufHandle* DoAllocateCanFail(CTranBufPool* pPool, int nSize) {  
  2.   BufHandle* pHdl;  
  3.   int nBlockSize = pPool->GetBlockSize();  
  4.   ASSERT(0 != nSize);  
  5.   
  6.   LOCK;  
  7.   pHdl = TObjectPool<BufHandle>::Allocate();  
  8.   // 以water mark0为标记.  
  9.   if (nSize == nBlockSize) {  
  10.     pHdl->pBuf = pPool->Allocate(0);  
  11.   } else {  
  12.     pHdl->pBuf = pPool->Allocate(0, (nSize + nBlockSize - 1) / nBlockSize);  
  13.   }  
  14.   if (NULL == pHdl->pBuf) {  
  15.     TObjectPool<BufHandle>::Free(pHdl);  
  16.     pHdl = NULL;  
  17.   }  
  18.   UNLOCK;  
  19.   return pHdl;  
  20. }  

1.2.4.5 _DoAddRef

对于BufHandle的引用技术和TranPool引用计数有点不同，并且平时思考的也不同。BufHandle的引用计数 只是针对头部的BufHandle增加计数而共用其他部分的BufHandle.

(NOTICE)(dirlt):(不过在外部调用可以看到,CloneAndTerminate实际上也还是遍历了所有的Handle做引用计数).

[cpp]  view plain copy
  1. BufHandle* _DoAddRef(BufHandle* pHdl, BufHandle* pNext, BufHandle** * pppLast) {  
  2.   if (-1 != m_TranBufPool.AddRef(pHdl->pBuf) || -1 != m_BigBufPool.AddRef(pHdl->pBuf)) {  
  3.     BufHandle* pTmp = TObjectPool<BufHandle>::Allocate();  
  4.     pTmp->_next = pNext;  
  5.     pTmp->pBuf = pHdl->pBuf;  
  6.     pTmp->nBufLen = pHdl->nDataLen;  
  7.     pTmp->nDataLen = pHdl->nDataLen;  
  8.     *pppLast = &pTmp->_next;  
  9.     return pTmp;  
  10.   }  
  11.   return NULL;  
  12. }  

1.2.4.6 _DoFree

只是释放单个BufHandle对象.

[cpp]  view plain copy
  1. void _DoFree(BufHandle* pHdl) {  
  2.   if (-1 == m_TranBufPool.Free(pHdl->pBuf))  
  3.     m_BigBufPool.Free(pHdl->pBuf);  
  4.   TObjectPool<BufHandle>::Free(pHdl);  
  5. }  

1.2.4.7 AllocateBig

从BigTranBufPool里面分配大块内存.注意对于大块内存而言的话只允许分配一个Block.

[cpp]  view plain copy
  1. BufHandle* AllocateBig(bool bCanFail) {  
  2.   BufHandle* pHdl;  
  3.   
  4.   pHdl = bCanFail  
  5.          ? DoAllocateCanFail(&m_BigBufPool, SZ_BIG_BUF)  
  6.          : DoAllocate(&m_BigBufPool, 60); // 60s的延迟.  
  7.   if (pHdl) {  
  8.     pHdl->_next = NULL;  
  9.     pHdl->nBufLen = SZ_BIG_BUF;  
  10.     pHdl->nDataLen = 0;  
  11.   }  
  12.   return pHdl;  
  13. }  

1.2.4.8 AllocateCanFail

从TranBufPool里面分配连续内存出来.

[cpp]  view plain copy
  1. BufHandle* AllocateCanFail(int nSize) {  
  2.   BufHandle* pHdl = DoAllocateCanFail(&m_TranBufPool, nSize);  
  3.   if (pHdl) {  
  4.     pHdl->_next = NULL;  
  5.     pHdl->nBufLen = nSize;  
  6.     pHdl->nDataLen = 0;  
  7.   }  
  8.   return pHdl;  
  9. }  

1.2.4.9 AllocForBuf

为某个buf分配内存.把buf内容copy进来.并且设置pNext.pppLast表示最后一个节点的next字段指针(三指针比较难理解…)

[cpp]  view plain copy
  1. BufHandle* AllocForBuf(char* pBuf, int nLen, BufHandle* pNext, BufHandle** * pppLast) {  
  2.   BufHandle* pFirst, *pHdl, **ppLast;  
  3.   
  4.   pFirst = NULL;  
  5.   ppLast = &pFirst;  
  6.   while (nLen > 0) {  
  7.     pHdl = DoAllocate(&m_TranBufPool, 120); // 120s延迟.  
  8.   
  9.     pHdl->nBufLen = s_nBufSize;  
  10.     pHdl->nDataLen = nLen > s_nBufSize ? s_nBufSize : nLen;  
  11.     memcpy(pHdl->pBuf, pBuf, pHdl->nDataLen);  
  12.     pBuf += pHdl->nDataLen;  
  13.     nLen -= pHdl->nDataLen;  
  14.   
  15.     pHdl->_next = pNext; // 设置next字段内容  
  16.     *ppLast = pHdl;  
  17.     ppLast = &pHdl->_next; // 并且得到最后一个item的next字段指针.  
  18.     // 不过因为设置了pNext所以感觉不是特别有用.  
  19.   }  
  20.   if (pppLast) {  
  21.     *pppLast = ppLast;  
  22.   }  
  23.   return pFirst;  
  24. }  

1.2.4.10 Allocate
[cpp]  view plain copy
  1. // 如果是inpool的话，那么pubuf必须是pool分配出来的，  
  2. // 那么我们只是针对这个buffer做一个引用计数  
  3.   
  4. // 如果不是inpool的话，nLen==0或者是pBuf==NULL,分配出一个空单元出来.  
  5. // 否则需要做一个内存copy.使用上面AllocForBuf的API.  
  6. BufHandle* Allocate(bool bInPool = false, char* pBuf = NULL,  
  7.                     int nLen = 0, BufHandle* pNext = NULL  
  8.                    ) {  
  9.   BufHandle* pHdl;  
  10.   
  11.   UNLIKELY_IF (false == bInPool) {  
  12.     LOCK;  
  13.     pHdl = TObjectPool<BufHandle>::Allocate();  
  14.     if (-1 == m_TranBufPool.AddRef(pBuf))  
  15.       m_BigBufPool.AddRef(pBuf);  
  16.     UNLOCK;  
  17.   
  18.     pHdl->_next = pNext;  
  19.     pHdl->pBuf = pBuf;  
  20.     pHdl->nBufLen = nLen;  
  21.     pHdl->nDataLen = nLen;  
  22.     return pHdl;  
  23.   }  
  24.   if (pBuf == NULL || nLen == 0) {  
  25.     pHdl = DoAllocate(&m_TranBufPool, 120);  
  26.   
  27.     pHdl->_next = pNext;  
  28.     pHdl->nBufLen = s_nBufSize;  
  29.     pHdl->nDataLen = nLen;  
  30.     return pHdl;  
  31.   }  
  32.   
  33.   return AllocForBuf(pBuf, nLen, pNext, NULL);  
  34. }


1.2.4.11 ChainFree

释放[pHdl,pNext)链上的所有item.

[cpp]  view plain copy
  1. void ChainFree(BufHandle* pHdl, BufHandle* pNext) {  
  2.   BufHandle* pTmp;  
  3.   LOCK;  
  4.   for ( ; pHdl != pNext; pHdl = pTmp) {  
  5.     ASSERT(NULL != pHdl);  
  6.     pTmp = pHdl->_next;  
  7.     _DoFree(pHdl);  
  8.   }  
  9.   UNLOCK;  
  10. }  

1.2.4.12 CloneAndTerminate

这个API的语义在之前已经解释过了，来看看代码.

[cpp]  view plain copy
  1. BufHandle* CloneAndTerminate(BufHandle* pHdl, BufHandle* pNext,  
  2.                              int* pnLen, bool bCopyNonTranBuf  
  3.                             ) {  
  4.   BufHandle* pFirst, *pTmp, **ppLast, **ppLastTmp;  
  5.   int nLen = 0;  
  6.   
  7.   pFirst = NULL;  
  8.   ppLast = &pFirst;  
  9.   LOCK;  
  10.   for ( ; pHdl != pNext; pHdl = pHdl->_next) {  
  11.     pTmp = _DoAddRef(pHdl, NULL, &ppLastTmp); // 看看是否可以在直接做引用计数.  
  12.     if (NULL == pTmp) {  
  13.       if (bCopyNonTranBuf) { // 如果需要copy出来的话.  
  14.         UNLOCK;  
  15.         pTmp = AllocForBuf(pHdl->pBuf, pHdl->nDataLen, NULL, &ppLastTmp);  
  16.         LOCK;  
  17.       } else { // 如果显示说不copy只是引用内存的话,那么只是开辟Handle对象.  
  18.         pTmp = TObjectPool<BufHandle>::Allocate();  
  19.         pTmp->pBuf = pHdl->pBuf;  
  20.         pTmp->nDataLen = pTmp->nBufLen = pHdl->nDataLen;  
  21.         pTmp->_next = NULL;  
  22.         ppLastTmp = &pTmp->_next;  
  23.       }  
  24.     }  
  25.     nLen += pHdl->nDataLen;  
  26.     *ppLast = pTmp;  
  27.     ppLast = ppLastTmp;  
  28.   }  
  29.   UNLOCK;  
  30.   
  31.   if (pnLen) {  
  32.     *pnLen = nLen;  
  33.   }  
  34.   if (nLen) {  
  35.     return pFirst;  
  36.   }  
  37.   // 如果失败的话那么释放已经分配出来的.  
  38.   ChainFreeHdl(pFirst, NULL);  
  39.   return NULL;  
  40. }  

1.2.5 Kylin

这个模块主要负责框架的启动和停止，做了一些琐碎的事情方便用户，主要是下面这两个函数

[cpp]  view plain copy
  1. // 启动框架，使用多少个CPU,网络和磁盘线程，至少1个CPU和1个网络线程  
  2. // f表示线程初始化函数  
  3. // nTimerPrecision会影响到定时器实现.如果超时在时间精度一下的话都会通过ExecMan直接触发  
  4. // 否则都会必须通过RunTimer来进行检查  
  5. APF_ERROR InitKylin(int nExecWorkers, int nNetWorkers, int nDiskWorkers,  
  6.                     THREAD_INIT_PROC f, uint32 nTimerPrecision);  
  7. // bWait表示是否等待ExecMan的线程池正常停止，这个会在ExecMan部分提到  
  8. APF_ERROR StopKylin(bool bWait);  

对于InitKylin里面事情就是启动几个Manager，还做了一件tricky事情就是将SIGPIPE信号忽略了。而StopKylin就是停止这些Manager.我们需要仔细关注的就是这些Manager的启停。

1.2.6 ExecMan

1.2.6.1 Overview

我们首先看看ExecMan的接口

[cpp]  view plain copy
  1. #define g_pExecMan CExecMan::Instance() // 直接使用宏g_pExecMan就可以单例  
  2.   
  3. class CExecMan  
  4. {  
  5.     DECLARE_SINGLETON(CExecMan) // 单例模式  
  6.     public:  
  7.     ~CExecMan();  
  8.     APF_ERROR Start(int nWorkers, THREAD_INIT_PROC fInit, uint32 nTimerPrecision);  
  9.     void Stop(bool bWait);  
  10.   
  11.     // 插入一个任务  
  12.     APF_ERROR QueueExec(AsyncContext* pCtx, bool bClientReferred);  
  13.     // 插入一个紧急任务  
  14.     APF_ERROR QueueExecEmergent(AsyncContext* pCtx, bool bClientReferred);  
  15.     // todo(zhangyan04):  
  16.     APF_ERROR ProxyExec(int nAckCode, CAsyncClient* pClient, PROXY_EXEC_PROC fProc, ProxyExecCtx* pCtx);  
  17.     // 提交一个定时器任务  
  18.     APF_ERROR DelayExec(int nAction, CAsyncClient* pClient, uint32 nMilliseconds, AsyncContext* pCtx);  
  19.     // 取消一个任务  
  20.     APF_ERROR CancelExec(AsyncContext* pCtx);  
  21.     // 检查定时器  
  22.     void RunTimer();  
  23.   
  24.   private:  
  25.     CThreadPool m_ThreadPool;  
  26.     volatile int m_nCurJobs; // 在运行期间有多少Job正在被提交  
  27. };  

1.2.6.2 Start & Stop

Start逻辑很简单，包括计算1s对应多少cycle数目以及启动线程池。

[cpp]  view plain copy
  1. APF_ERROR CExecMan::Start(int nWorkers, THREAD_INIT_PROC fInit, uint32 nTimerPrecision)  
  2. {  
  3.     // 计算一下CPU一个tick有多少个cycle数目，这样可以通过rdstc转换成为时间  
  4.     g_nCycleStart = rdtsc();  
  5.     g_nLastTick = 0;  
  6.     g_nTickPrecision = (nTimerPrecision >= 1000) ? 1000 : nTimerPrecision;  
  7.     g_nCyclesInTick = GetCpuFreq() / (1000 / g_nTickPrecision);  
  8.     if (0 < m_ThreadPool.Start(nWorkers, fInit)) { // 启动线程池  
  9.         AtomicSetValue(m_nCurJobs, 0);  
  10.         return APFE_OK;  
  11.     }  
  12.     return APFE_SYS_ERROR;  
  13. }  

Stop逻辑的话可能需要仔细理解一下

[cpp]  view plain copy
  1. // bWait表示是否需要等待kylin的线程池正常结束，执行完成线程池里面任务为止。  
  2. // 不断修正m_nCurJobs作用是为了阻止新任务的提交。这个我们可以在QueuExec部分联合起来一起看看  
  3. void CExecMan::Stop(bool bWait)  
  4. {  
  5.     if (bWait) {  
  6.         int n;  
  7.         while (0 != (n=atomic_comp_swap(&m_nCurJobs, LARGE_ENOUGH_NEGATIVE, 0))) {  
  8.             if (LARGE_ENOUGH_NEGATIVE == n) {  
  9.                 return;  
  10.             }  
  11.             Sleep(1);  
  12.         }  
  13.         m_ThreadPool.Stop();  
  14.     }  
  15.     else {  
  16.         AtomicSetValue(m_nCurJobs, LARGE_ENOUGH_NEGATIVE);  
  17.     }  
  18. }  

1.2.6.3 QueueExec

QueueExec和QueueExecEmergent逻辑非常相似，只不过底层调用线程池的QueueJob和QueueEmergentJob.我们这里只看QueueExec.

[cpp]  view plain copy
  1. static void  
  2. Proc(Job* pJob)  
  3. {  
  4.     AsyncContext* pCtx = (AsyncContext*)pJob;  
  5.     CAsyncClient* pClient = pCtx->pClient;  
  6.   
  7.     pCtx->fProc = NULL;  
  8.     pClient->OnCompletion(pCtx);  
  9.     pClient->Release();  
  10. }  
  11.   
  12. // bClientReferref表明用户是否加了引用  
  13. // 如果按照sunxiao的说明，我们这里最好永远写true,然后我们在外面调用点自己AddRef和DecRef  
  14. APF_ERROR CExecMan::QueueExec(AsyncContext* pCtx, bool bClientReferred)  
  15. {  
  16.     VERIFY_OR_RETURN(NULL != pCtx, APFE_INVALID_ARGS);  
  17.     VERIFY_OR_RETURN(NULL != pCtx->pClient, APFE_INVALID_ARGS);  
  18.   
  19.     // 如果atomic +1 <0的话，那么说明这个时候m_nCurJobs已经被置过LARGE_ENOUGH_NEGATIVE了  
  20.     // 当然我们是有假设m_nCurJobs不会非常快地复位，可以认为这个是成立的  
  21.     if (atomic_add(&m_nCurJobs, 1) >= 0) {  
  22.         // TODO: if the number of workers is dynamic, we may need to lock and re-dispatch exisiting events...  
  23.         if (!bClientReferred) {  
  24.             pCtx->pClient->AddRef();  
  25.         }  
  26.         pCtx->fProc = Proc; // 置ctx的fProc为Proc  
  27.         // 然后根据client的AsyncId来决定指派到哪一个线程工作  
  28.         m_ThreadPool.QueueJob((Job*)pCtx, pCtx->pClient->GetAsyncId() % m_ThreadPool.GetWorkerCount());  
  29.         atomic_add(&m_nCurJobs, -1); // 将当前正在提交的Jobs个数-1.  
  30.         return APFE_OK;  
  31.     }  
  32.     if (bClientReferred) {  
  33.         pCtx->pClient->Release();  
  34.     }  
  35.     // 那么将m_nCurJobs重置  
  36.     AtomicSetValue(m_nCurJobs, LARGE_ENOUGH_NEGATIVE);  
  37.     if (IsKylinRunning()) {  
  38.         TRACE0(<span class="org-string">"Fatal error: Exec workers are not started\n"</span>);  
  39.     }  
  40.     return APFE_NO_WORKER;  
  41. }  

我们这里可以看到m_nCurJobs在QueueExec和Stop之间的配合。然后我们稍微看看Proc这个过程，对于CPU任务直接调用OnCompletion然后调用Release.

1.2.6.4 Timer

定时器任务加入是DelayExec,检查触发是RunTimer.如果查看CallGraph的话会发现RunTimer都是在网络部分调用的，我们在网络部分看看触发的时机。 DelayExec里面的逻辑会根据定时时间来判断如何实现，如果定时时间超过g_nTickPrecision，那么会将超时时间加入一个map里面去，然后让RunTimer去触发。 否则会加入线程池里面去。对于加入到map里面的fProc有一个特殊的标记(JOB_PROC)2.在CancelExec时候会认识这个特殊标记，将事件从map中删除。

[cpp]  view plain copy
  1. APF_ERROR CExecMan::DelayExec(int nAction, CAsyncClient* pClient, uint32 nMilliseconds, AsyncContext* pCtx)  
  2. {  
  3.     VERIFY_OR_RETURN(NULL != pClient, APFE_INVALID_ARGS);  
  4.     VERIFY_OR_RETURN(NULL != pCtx, APFE_INVALID_ARGS);  
  5.   
  6.     pCtx->nAction = nAction;  
  7.     pCtx->pClient = pClient;  
  8.     pCtx->fProc = (JOB_PROC)2;  
  9.   
  10.     if (g_nTickPrecision <= nMilliseconds) {  
  11.         pClient->AddRef();  
  12.   
  13.         s_Lock.Lock();  
  14.         /* milliseconds -> ticks */  
  15.         nMilliseconds = g_nLastTick + nMilliseconds / g_nTickPrecision;  
  16.         pCtx->nErrCode = nMilliseconds;  
  17.         s_TimerMap.insert(nMilliseconds, pCtx);  
  18.         s_Lock.Unlock();  
  19.         return APFE_OK;  
  20.     }  
  21.   
  22.     APF_ERROR err;  
  23.     s_Lock.Lock();  
  24.     err = QueueExec(pCtx, false);  
  25.     s_Lock.Unlock();  
  26.     return err;  
  27. }  

然后我看看看RunTimer这个部分。这个部分非常简单，就是根据当前时间判断map里面哪些定时器需要进行触发，然后将触发逻辑作为Job丢入CPU线程池。 我们这里不看RunTimer具体代码，反而倒是对外面的一些小细节比较感兴趣。我们不希望RunTimer被多个实例调用，只要有一个实例调用就OK，使用CToken完成。 当然可以使用mutex+try_lock来实现但是开销应该会更大。

[cpp]  view plain copy
  1. void CExecMan::RunTimer()  
  2. {  
  3.     static CToken token;  
  4.     UNLIKELY_IF (!token.TryAcquire(1)) {  
  5.         return;  
  6.     }  
  7.     // ...  
  8.     token.Release(1);  
  9. }  

1.2.6.5 Example

我们这里给的例子非常简单，但是希望有启发性.我们从1开始进行打印，每打印1个数字就认为当前任务结束，一直无限打印。 但是我们同时会启动一个定时器，只允许我们做1.2s钟时间的打印。如果我们在1.2s内打印数字个数超过了100个的话，那么我们重启一个定时器1.2s， 而这次打印数字个数阈值为200个之后每次翻倍，直到1.2s内没有打印我们所希望个数的话程序退出。在主线程100ms来检查ExecMan的RunTimer.

#include <cstdio>
#include <vector>
#include <time.h>
#include <span class="org-string">"stdafx.h"</span>
#include <span class="org-string">"Kylin.h"</span>

static volatile int worker=16;
static const int PRINT=0;
static const int TIMEOUT=1;
static const int TIMEOUT_MS=1200;

class XAsyncClient:public CAsyncClient{
  public:
    AsyncContext print_ctx;
    AsyncContext delay_ctx;
    int id;
    int current_number;
    int threshold;
    int last_working_number;
    bool stop; // 一旦stop那么立刻后面内容都不打印了
    XAsyncClient(int id_):
            id(id_),
            current_number(1),
            threshold(100),
            last_working_number(0),
            stop(false){
        InitAsyncContext(&print_ctx);
        InitAsyncContext(&delay_ctx);
        print_ctx.pClient=this;
        delay_ctx.pClient=this;
    }
    int Release(){ // Release通常都是这样写的
        int n=CAsyncClient::Release();
        if(n==0){
            delete this;
        }
        return n;
    }
    void Start(){ // 启动时候我们发起两个Job
        print_ctx.nAction=PRINT;
        CAsyncClient::AddRef();
        g_pExecMan->QueueExec(&print_ctx,true);
        CAsyncClient::AddRef();
        g_pExecMan->DelayExec(TIMEOUT,this,TIMEOUT_MS,&delay_ctx);
    }
    void Print(){
        fprintf(stderr,<span class="org-string">"(%d)xref:%d,current:%d\n"</span>,id,CAsyncClient::GetRef(),
                current_number);
    }
    virtual void OnCompletion(AsyncContext* ctx){
        switch(ctx->nAction){ // 分别处理这两个类型Job
            case PRINT:
                if(stop){
                    break;
                }
                fprintf(stderr,<span class="org-string">"(%d)%d\n"</span>,id,current_number);
                current_number++;
                if((current_number-last_working_number)>=threshold){
                    // update
                    last_working_number=current_number;
                    threshold*=2;
                    // canel timer.
                    fprintf(stderr,<span class="org-string">"(%d)==============================restart timer==============================\n"</span>,id);
                    g_pExecMan->CancelExec(&delay_ctx);
                    g_pExecMan->DelayExec(TIMEOUT,this,TIMEOUT_MS,&delay_ctx);
                }
                CAsyncClient::AddRef();
                g_pExecMan->QueueExec(&print_ctx,true);
                break;
            case TIMEOUT:
                fprintf(stderr,<span class="org-string">"(%d)********************quit********************\n"</span>,id);
                atomic_add(&worker,-1);
                stop=true;
                break;
            default:
                assert(0);
        }
    }
};

int main(){
    // use 4 exec threads.
    InitKylin(4,0,0);
    // 100ms
    const struct timespec spec={0,100*1000000};
    const int worker_num=worker;
    std::vector< XAsyncClient* > vec;
    for(int i=0;i<worker_num;i++){
        XAsyncClient* client=new XAsyncClient(i);
        vec.push_back(client);
        client->Start();
    }
    while(1){
        nanosleep(&spec,NULL);
        //Sleep(1);
        if(AtomicGetValue(worker)==0){
            StopKylin(true);
            break;
        }else{ // 主线程我们每隔100ms检查一次超时情况
            g_pExecMan->RunTimer();
        }
    }
    for(int i=0;i<worker_num;i++){
        XAsyncClient* client=vec[i];
        client->Print(); // 退出时候打印一下信息
        delete client;
    }
    return 0;
}

 
    
 
   
 
  
 
  
 
   
1.2.7 DiskMan
 
   
 
   
 
    
1.2.7.1 Overview
 
    
 
     
我们首先看看和磁盘相关的两个比较重要的类。因为磁盘操作不像CPU操作一样不需要任何辅助数据结构，磁盘操作需要一些信息比如fd等，磁盘操作需要一个特殊的磁盘Context。 然后每次发起磁盘操作使用另外一个结构Request.这里名字上和原来的CPU事件并不太一样，我们可能需要习惯一下。实际上如果我们需要映射到CPU事件里面的话，这两个Context应该结合在一起。 只不过这里DiskContext不是经常变动的部分，而DiskRequest是经常变动的部分所以分离开了。
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  // 这个是磁盘操作相关的Context  
    2.  
       
  2.  struct DiskContext {  
    3.  
       
  3.      int fd;  
    4.  
       
  4.      int diskno;// which disk  
    5.  
       
  5.      CAsyncClient *pClient;  
    6.  
       
  6.      uint64 nCurOff, nRead, nWrite;  
    7.  
       
  7.      char* pPath;// file path  
    8.  
       
  8.      int nFlag;// file open flag  
    9.  
       
  9.  };  
    10.  
       
  10.    
    11.  
       
  11.  // 这个是一次发起的请求  
    12.  
       
  12.  struct DiskRequest {  
    13.  
       
  13.      union { // 这里使用这种方式纯粹是为了写起来方便  
    14.  
       
  14.          AsyncContext async;  
    15.  
       
  15.          Job job;  
    16.  
       
  16.      };  
    17.  
       
  17.      /* !!the first element must be AsyncContext */  
    18.  
       
  18.      void *buf; // 读写放到什么地方  
    19.  
       
  19.      int request; // 读写多少字节数据  
    20.  
       
  20.      int xfered; //当前实际读写了多少数据  
    21.  
       
  21.      uint64 off; // 在什么偏移上读写  
    22.  
       
  22.      DiskContext *pCtx;  
    23.  
       
  23.  };  
    24.  
      
 
     
 
     
 
     
然后在看看DiskMan接口
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  #define g_pDiskMan CDiskMan::Instance() // 直接使用宏g_pDiskMan就可以单例  
    2.  
       
  2.    
    3.  
       
  3.  class CDiskMan  
    4.  
       
  4.  {  
    5.  
       
  5.      DECLARE_SINGLETON(CDiskMan) // 单例模式  
    6.  
       
  6.      public:  
    7.  
       
  7.      ~CDiskMan();  
    8.  
       
  8.    
    9.  
       
  9.      APF_ERROR Start(int nDisks, THREAD_INIT_PROC fInit);  
    10.  
       
  10.      void Stop();  
    11.  
       
  11.    
    12.  
       
  12.      APF_ERROR Associate(int diskno, int fd, CAsyncClient* pClient, DiskContext* pContext);  
    13.  
       
  13.      APF_ERROR Associate(int diskno, char* pPath, int nFlag, CAsyncClient* pClient, DiskContext* pContext);  
    14.  
       
  14.      APF_ERROR Deassociate(DiskContext* pContext);  
    15.  
       
  15.    
    16.  
       
  16.      void Read(DiskContext* pContext, void* pBuf, int count, DiskRequest* pReq);  
    17.  
       
  17.      void Write(DiskContext* pContext, void* pBuf, int count, DiskRequest* pReq);  
    18.  
       
  18.    
    19.  
       
  19.    private:  
    20.  
       
  20.      CThreadPool m_ThreadPool;  
    21.  
       
  21.      bool m_bStarted;  
    22.  
       
  22.  };  
    23.  
      
 
     
 
     
 
    
 
   
 
   
 
    
1.2.7.2 Start & Stop
 
    
 
     
启动停止逻辑非常简单，就是让线程池启动和停止
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  APF_ERROR CDiskMan::Start(int nDisks, THREAD_INIT_PROC fInit)  
    2.  
       
  2.  {  
    3.  
       
  3.      ASSERT(nDisks <= MAX_NR_DISKS);  
    4.  
       
  4.      ASSERT(!IsStarted());  
    5.  
       
  5.      // TODO::: if 0 then check the number of disks  
    6.  
       
  6.      if (m_ThreadPool.Start(nDisks, fInit) > 0) {  
    7.  
       
  7.          m_bStarted = true;  
    8.  
       
  8.          return APFE_OK;  
    9.  
       
  9.      }  
    10.  
       
  10.      return APFE_SYS_ERROR;  
    11.  
       
  11.  }  
    12.  
       
  12.    
    13.  
       
  13.  void CDiskMan::Stop()  
    14.  
       
  14.  {  
    15.  
       
  15.      if (m_bStarted) {  
    16.  
       
  16.          m_bStarted = false;  
    17.  
       
  17.          m_ThreadPool.Stop();  
    18.  
       
  18.      }  
    19.  
       
  19.  }  
    20.  
      
 
     
 
     
 
    
 
   
 
   
 
    
1.2.7.3 Associate & Deassociate
 
    
 
     
逻辑非常简单，就是进行一下DiskContext和CAsyncClient初始化的工作。关于DiskContext里面各个字段含义的话，都是在Read/Write时候解释的。 关于这里最重点的绑定内容就是diskno.diskno非常作用类似于CPU事件里面的AsyncId.相同AsyncId可以分摊到同一个CPU线程这件可以免去加锁开销， 而diskno可以让多个DiskContext分摊到同一个Disk线程，不同线程绑定不同的磁盘驱动器，这样可以让同一个磁盘驱动器仅仅为几个文件服务。
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  APF_ERROR CDiskMan::Associate(int diskno, char* pPath, int nFlag,  
    2.  
       
  2.                                CAsyncClient* pClient, DiskContext* pContext)  
    3.  
       
  3.  {  
    4.  
       
  4.      pContext->fd = -1;  
    5.  
       
  5.      pContext->diskno = diskno;  
    6.  
       
  6.      pContext->pClient = pClient;  
    7.  
       
  7.      pContext->nCurOff = pContext->nRead = pContext->nWrite = 0;  
    8.  
       
  8.      pContext->pPath = pPath;  
    9.  
       
  9.      pContext->nFlag = nFlag;  
    10.  
       
  10.      pClient->AddRef();  
    11.  
       
  11.      return APFE_OK;  
    12.  
       
  12.  }  
    13.  
       
  13.    
    14.  
       
  14.  APF_ERROR CDiskMan::Deassociate(DiskContext* pContext)  
    15.  
       
  15.  {  
    16.  
       
  16.      if (pContext->pPath && pContext->fd!=-1) {  
    17.  
       
  17.          close(pContext->fd);  
    18.  
       
  18.      }  
    19.  
       
  19.      pContext->pClient->Release();  
    20.  
       
  20.      return APFE_OK;  
    21.  
       
  21.  }  
    22.  
      
 
     
 
     
 
    
 
   
 
   
 
    
1.2.7.4 Read & Write
 
    
 
     
文件的Read/Write非常简单，因为本身就是一个阻塞的过程，发起一次就可以保证读取所有内容了，所以不像网络一样需要多次发起。
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  void CDiskMan::Read(DiskContext* pContext, void* pBuf, int count, DiskRequest* pReq)  
    2.  
       
  2.  {  
    3.  
       
  3.      pReq->async.nAction = AA_READ; // 设置nAction,然后QueueTask,Task中回调就是ReadOp  
    4.  
       
  4.      QUEUE_TASK(pContext, pReq, ReadOp, pBuf, count);  
    5.  
       
  5.  }  
    6.  
       
  6.    
    7.  
       
  7.  void CDiskMan::Write(DiskContext* pContext, void* pBuf, int count, DiskRequest* pReq)  
    8.  
       
  8.  {  
    9.  
       
  9.      pReq->async.nAction = AA_WRITE; // 设置nAction,然后QueueTask,Task中回调就是WriteOp  
    10.  
       
  10.      QUEUE_TASK(pContext, pReq, WriteOp, pBuf, count);  
    11.  
       
  11.  }  
    12.  
       
  12.    
    13.  
       
  13.  // 可以看到这里pClient已经帮我们AddRef了，所以我们在实际编写App不需要再次AddRef  
    14.  
       
  14.  #define QUEUE_TASK(pContext, pReq, f, pBuf, count)                  \  
    15.  
       
  15.      pContext->pClient->AddRef();                                    \  
    16.  
       
  16.      pReq->async.pClient = pContext->pClient;                        \  
    17.  
       
  17.      pReq->job.fProc = f;                                            \  
    18.  
       
  18.      pReq->buf = pBuf;                                               \  
    19.  
       
  19.      pReq->request = count;                                          \  
    20.  
       
  20.      pReq->xfered = 0;                                               \  
    21.  
       
  21.      pReq->pCtx = pContext;                                          \  
    22.  
       
  22.      m_ThreadPool.QueueJob(&pReq->job, pContext->diskno)  
    23.  
      
 
     
 
     
 
     
从上面分析的话，所有重要的工作都分摊在了ReadOp和WriteOp上面。我们需要做的是Dig下去看看两个是怎么工作的。但是很不幸，两个函数里面内容都是使用了宏DiskOp. DiskOp(a,b,c)其中a表示对应的系统调用叫什么名字，b表示这个Job,c表示读写(没有使用).
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  static void  
    2.  
       
  2.  ReadOp(Job* pJob)  
    3.  
       
  3.  {  
    4.  
       
  4.      DISK_OP(read, pJob, 0);  
    5.  
       
  5.  }  
    6.  
       
  6.    
    7.  
       
  7.  static void  
    8.  
       
  8.  WriteOp(Job* pJob)  
    9.  
       
  9.  {  
    10.  
       
  10.      DISK_OP(write, pJob, 1);  
    11.  
       
  11.  }  
    12.  
      
 
     
 
     
 
     
继续Dig看看DISKOP是怎么工作的
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  // 完成之后设置ErrCode,并且加入CPU线程池。用户最终处理的话需要强制转换DiskRequest.  
    2.  
       
  2.  #define NotifyClient(err, req)    {                                     \  
    3.  
       
  3.          req->async.nErrCode = err;                                      \  
    4.  
       
  4.          g_pExecMan->QueueExec((AsyncContext*)req, true);                \  
    5.  
       
  5.      }  
    6.  
       
  6.    
    7.  
       
  7.  // 1.可以看到如果fd==-1的话会自动打开文件  
    8.  
       
  8.  // 2.判断一下发起的off和context是否一致，不一致的话使用pread/pwrite,然后修改off  
    9.  
       
  9.  // 3.读取完成之后使用NotifyClient通知App  
    10.  
       
  10.  #define DISK_OP(op, j, rw)                                              \  
    11.  
       
  11.      DiskRequest* pReq = CONTAINING_RECORD(j, DiskRequest, job);         \  
    12.  
       
  12.      DiskContext* pCtx = pReq->pCtx;                                     \  
    13.  
       
  13.      UNLIKELY_IF (-1 == pCtx->fd) {                                      \  
    14.  
       
  14.          pCtx->fd = open(pCtx->pPath, pCtx->nFlag, 0644);                \  
    15.  
       
  15.          UNLIKELY_IF (-1 == pCtx->fd) {                                  \  
    16.  
       
  16.              NotifyClient(errno, pReq);                                  \  
    17.  
       
  17.              return;                                                     \  
    18.  
       
  18.          }                                                               \  
    19.  
       
  19.      }                                                                   \  
    20.  
       
  20.      uint64 cost = rdtsc();                                              \  
    21.  
       
  21.      int len;                                                            \  
    22.  
       
  22.      if (pReq->off != pCtx->nCurOff) {                                   \  
    23.  
       
  23.          len = p ## op(pCtx->fd, pReq->buf, pReq->request, pReq->off);   \  
    24.  
       
  24.          pCtx->nCurOff = pReq->off;                                      \  
    25.  
       
  25.      }                                                                   \  
    26.  
       
  26.      else {                                                              \  
    27.  
       
  27.          len = op(pCtx->fd, pReq->buf, pReq->request);                   \  
    28.  
       
  28.      }                                                                   \  
    29.  
       
  29.      if (len >= 0) {                                                     \  
    30.  
       
  30.          cost = rdtsc() - cost;                                          \  
    31.  
       
  31.          int which = (pCtx->diskno<<1) + rw;                             \  
    32.  
       
  32.          g_nDiskStats[which] += len;                                     \  
    33.  
       
  33.          g_nDiskCosts[which] += cost;                                    \  
    34.  
       
  34.          pCtx->nCurOff += len;                                           \  
    35.  
       
  35.          pReq->off += len;                                               \  
    36.  
       
  36.          pReq->xfered = len;                                             \  
    37.  
       
  37.          NotifyClient(0, pReq);                                          \  
    38.  
       
  38.      }                                                                   \  
    39.  
       
  39.      else {                                                              \  
    40.  
       
  40.          NotifyClient(errno, pReq);                                      \  
    41.  
       
  41.      }  
    42.  
      
 
     
 
     
 
    
 
   
 
   
 
    
1.2.7.5 Example
 
    
 
     
例子非常简单就是我们首先发起一个磁盘操作写文件然后在将去读取出来。
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  #include <cstdio>  
    2.  
       
  2.  #include <vector>  
    3.  
       
  3.  #include <string>  
    4.  
       
  4.  #include <time.h>  
    5.  
       
  5.  #include <span class="org-string">"stdafx.h"</span>  
    6.  
       
  6.  #include <span class="org-string">"Kylin.h"</span>  
    7.  
       
  7.    
    8.  
       
  8.  static const int worker_num=8;  
    9.  
       
  9.  static volatile int worker=worker_num;  
    10.  
       
  10.  static const char* fname_prefix=<span class="org-string">"hello"</span>;  
    11.  
       
  11.  static const char* content=<span class="org-string">"world"</span>;  
    12.  
       
  12.  static const int READ=0;  
    13.  
       
  13.  static const int WRITE=1;  
    14.  
       
  14.  static const int disk_thread_num=4;  
    15.  
       
  15.    
    16.  
       
  16.  class XDiskRequest:public DiskRequest{  
    17.  
       
  17.    public:  
    18.  
       
  18.      int nAction; // what kind of operation we init.  
    19.  
       
  19.  };  
    20.  
       
  20.    
    21.  
       
  21.  class XAsyncClient:public CAsyncClient{  
    22.  
       
  22.    public:  
    23.  
       
  23.      int id;  
    24.  
       
  24.      std::string name;  
    25.  
       
  25.      DiskContext disk_ctx;  
    26.  
       
  26.      XDiskRequest disk_req;  
    27.  
       
  27.      XAsyncClient(int id_):  
    28.  
       
  28.              id(id_){  
    29.  
       
  29.          // make filename.  
    30.  
       
  30.          char tmp[128];  
    31.  
       
  31.          snprintf(tmp,sizeof(tmp),<span class="org-string">"%s_%d"</span>,fname_prefix,id);  
    32.  
       
  32.          name=tmp;  
    33.  
       
  33.          g_pDiskMan->Associate(id%disk_thread_num,const_cast<char*>(name.c_str()),O_RDWR | O_CREAT,this,&disk_ctx);  
    34.  
       
  34.      }  
    35.  
       
  35.      ~XAsyncClient(){  
    36.  
       
  36.          g_pDiskMan->Deassociate(&disk_ctx);  
    37.  
       
  37.      }  
    38.  
       
  38.      void Start(){  
    39.  
       
  39.          disk_req.nAction=WRITE;  
    40.  
       
  40.          char* s=strdup(content);  
    41.  
       
  41.          // ctx off=0.write from the beginning  
    42.  
       
  42.          g_pDiskMan->Write(&disk_ctx,s,strlen(s)+1,&disk_req);  
    43.  
       
  43.      }  
    44.  
       
  44.      void Print(){  
    45.  
       
  45.          fprintf(stderr,<span class="org-string">"(%d)xref:%d\n"</span>,id,CAsyncClient::GetRef());  
    46.  
       
  46.      }  
    47.  
       
  47.      virtual void OnCompletion(AsyncContext* ctx){  
    48.  
       
  48.          XDiskRequest* req=(XDiskRequest*)ctx;  
    49.  
       
  49.          if(req->nAction==WRITE){  
    50.  
       
  50.              assert(req->xfered==req->request);  
    51.  
       
  51.              // free written buffer.  
    52.  
       
  52.              free(req->buf);  
    53.  
       
  53.              // begin to read.  
    54.  
       
  54.              disk_req.nAction=READ;  
    55.  
       
  55.              disk_req.off=0; // read from beginning  
    56.  
       
  56.              char* s=(char*)malloc(req->request);  
    57.  
       
  57.              g_pDiskMan->Read(&disk_ctx,s,req->request,&disk_req);  
    58.  
       
  58.          }else if(req->nAction==READ){  
    59.  
       
  59.              assert(req->xfered==req->request);  
    60.  
       
  60.              fprintf(stderr,<span class="org-string">"(%d)%s\n"</span>,id,req->buf);  
    61.  
       
  61.              // free read buffer.  
    62.  
       
  62.              free(req->buf);  
    63.  
       
  63.              atomic_add(&worker,-1);  
    64.  
       
  64.          }  
    65.  
       
  65.      }  
    66.  
       
  66.  };  
    67.  
       
  67.    
    68.  
       
  68.  int main(){  
    69.  
       
  69.      // use 4 disk threads.  
    70.  
       
  70.      InitKylin(1,1,disk_thread_num);  
    71.  
       
  71.      std::vector< XAsyncClient* > vec;  
    72.  
       
  72.      for(int i=0;i<worker_num;i++){  
    73.  
       
  73.          XAsyncClient* client=new XAsyncClient(i);  
    74.  
       
  74.          vec.push_back(client);  
    75.  
       
  75.          client->Start();  
    76.  
       
  76.      }  
    77.  
       
  77.      // 100ms.  
    78.  
       
  78.      const struct timespec timeout={0,100*1000000};  
    79.  
       
  79.      while(1){  
    80.  
       
  80.          nanosleep(&timeout,NULL);  
    81.  
       
  81.          if(AtomicGetValue(worker)==0){  
    82.  
       
  82.              StopKylin(true);  
    83.  
       
  83.              break;  
    84.  
       
  84.          }  
    85.  
       
  85.      }  
    86.  
       
  86.      for(int i=0;i<worker_num;i++){  
    87.  
       
  87.          XAsyncClient* client=vec[i];  
    88.  
       
  88.          client->Print();  
    89.  
       
  89.          delete client;  
    90.  
       
  90.      }  
    91.  
       
  91.      return 0;  
    92.  
       
  92.  }  
    93.  
      
 
     
 
     
 
    
 
   
 
  
 
  
 
   
1.2.8 NetworkMan
 
   
 
   
 
    
1.2.8.1 Overview
 
    
 
     
和网络相关的也有两个比较重要的类。同样和DiskMan相同，NetworkMan也提供了NetContext和NetRequest.
 
     
 
      
 
       
 
        [cpp]  view plain copy 
        
 
        
 
       
 
      
 
      
     
       
  1.  // 网络请求  
    2.  
       
  2.  struct NetRequest {  
    3.  
       
  3.      union {  
    4.  
       
  4.          AsyncContext async;  
    5.  
       
  5.          DLINK link;  
    6.  
       
  6.      };  
    7.  
       
  7.      /* !! the first element must be AsyncContext */  
    8.  
       
  8.      union {  
    9.  
       
  9.          BufHandle hdl;  
    10.  
       
  10.          struct {  
    11.  
       
  11.              BufHandle *pHdl;    // not used by read  
    12.  
       
  12.              void* buf;  
    13.  
       
  13.              int len;            // buffer len  
    14.  
       
  14.              int request;        // request len  
    15.  
       
  15.          };  
    16.  
       
  16.      };  
    17.  
       
  17.      int xfered; // 已经读取了多少个字节  
    18.  
       
  18.      uint32 ip;                  // for UDP  
    19.  
       
  19.      uint16 port;                // for UDP  
    20.  
       
  20.  };  
    21.  
       
  21.    
    22.  
       
  22.  // Socket相关状态  
    23.  
       
  23.  enum SocketState {  
    24.  
       
  24.      SS_VOID = 0,  
    25.  
       
  25.      SS_LISTENING_0,  
    26.  
       
  26.      SS_LISTENING,  
    27.  
       
  27.      SS_CONNECTING_0,  
    28.  
       
  28.      SS_CONNECTING,  
    29.  
       
  29.      SS_CONNECTED_0,  
    30.  
       
  30.      SS_CONNECTED,  
    31.  
       
  31.      SS_ERROR,  
    32.  
       
  32.      SS_SHUTDOWN,  
    33.  
       
  33.  };  
    34.  
       
  34.    
    35.  
       
  35.  // Socket Flag  
    36.  
       
  36.  enum SocketFlag {  
    37.  
       
  37.      SF_DIRECT_CALLBACK  = 0x1, // 处理完成之后回调函数直接在Network线程执行而不丢到CPU线程  
    38.  
       
  38.      SF_PERMANENT        = 0x2, // todo(zhangyan04):???  
    39.  
       
  39.      SF_UDP              = 0x4, // 使用UDP协议  
    40.  
       
  40.      SF_DONT_EXHAUST     = 0x8, // todo(zhangyan04):???  
    41.  
       
  41.  };  
    42.  
       
  42.    
    43.  
       
  43.  // 网络相关操作的Context  
    44.  
       
  44.  struct NetContext {  
    45.  
       
  45.      SOCKET s; // 网络socket  
    46.  
       
  46.      SocketState state; // socket状态  
    47.  
       
  47.    
    48.  
       
  48.      DLINK link;                 // to link all active sockets  
    49.  
       
  49.      CLockedInt tWrite, tRead; // todo(zhangyan04):???  
    50.  
       
  50.      TranQueue qRead, qWrite; // 读写请求队列，push_back和pop_front需要加锁但是不用等待。  
    51.  
       
  51.      NetRequest *pReadReq, *pWriteReq; // 当前读写请求  
    52.  
       
  52.      BufHandle wHdl; // 写BufHandle,StartWrite里面多次写的话当前BufHandle就保存在这里。  
    53.  
       
  53.      // nDelayRead表示是否已经发生了Delay操作，不允许多次发起Delay操作  
    54.  
       
  54.      // nEnabled表示当前Context是否可用  
    55.  
       
  55.      volatile int nDelayRead, nEnabled;  
    56.  
       
  56.      uint32 nTimeout; // 超时时间  
    57.  
       
  57.      uint64 tTimeoutCycle; // 超时时间转换成为的cycle,类似于一个绝对的超时时间  
    58.  
       
  58.    
    59.  
       
  59.      CAsyncClient *pClient; // 关联的client  
    60.  
       
  60.      CEPoller* pPoller; // 底层poller  
    61.  
      
 
     
 
    
 
   
 
  
 
 
 


                            

                        

                    

                    
                    

                    
                    
                    

                

                

                    
                

            

        

    

    

        
你可能感兴趣的:(多线程,C++)

        

            

                
    
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    
                    
    • 
                    
  • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    
                    
    • 
                    
  • 多线程之——ExecutorCompletionService
                        阿福德

                        
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • python多线程程序设计 之一
                        IT_Beijing_BIT
#Python程序设计语言python
                        
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
    
                    
    • 
                    
  • C++ lambda闭包消除类成员变量
                        barbyQAQ
c++c++java算法
                        
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
    
                    
    • 
                    
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码）
                        mmz1207
c++csp
                        
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧
                        Lenyiin
C++修炼全景指南技术指南c++算法stl
                        
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
    
                    
    • 
                    
  • Python多线程实现大规模数据集高效转移
                        sand&wich
网络python服务器
                        
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    
                    
    • 
                    
  • Python实现下载当前年份的谷歌影像
                        sand&wich
python开发语言
                        
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    
                    
    • 
                    
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码）
                        X_StarX
c++学习算法大学生开发语言数据结构
                        
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
    
                    
    • 
                    
  • C++八股
                        Petrichorzncu
八股总结c++开发语言
                        
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】
                        汉子萌萌哒
CCFnoi算法数据结构c++
                        
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • c++ opencv4.3 sift匹配
                        图像处理大大大大大牛啊
图像处理opencv实战代码讲解opencvsiftc++opencv4特征点
                        
    c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • c++ 内存处理函数
                        heeheeai
c++开发语言
                        
    在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
    
                    
    • 
                    
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】
                        XWWW668899
C++基本概念c++c语言开发语言青少年编程
                        
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
    
                    
    • 
                    
  • C++常见知识掌握
                        nfgo
c++开发语言
                        
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
    
                    
    • 
                    
  • metaRTC5.0 API编程指南(一)
                        metaRTC
metaRTCc++c语言webrtc
                        
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
    
                    
    • 
                    
  • sublime个人设置
                        bawangtianzun
sublimetext编辑器
                        
    如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
    
                    
    • 
                    
  • Rust是否会取代C/C++？Rust与C/C++的较量
                        AI与编程之窗
源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
                        
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
    
                    
    • 
                    
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗
                        靖dede
python可以制作大型游戏
                        
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
    
                    
    • 
                    
  • Python开发游戏？也太好用了吧
                        七步编程
工具Githubpythonpython游戏开发语言
                        
    程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
    
                    
    • 
                    
  • Go编程语言前景怎么样？参加培训好就业吗
                        QFdongdong

                        
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
    
                    
    • 
                                
  • 安装数据库首次应用
                                    Array_06
javaoraclesql
                                    
    可是为什么再一次失败之后就变成直接跳过那个要求 
enter full pathname of java.exe的界面 
 
 
这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 
注意第一次，使用SQL D
    
                                
    • 
                                
  • Weblogic Server Console密码修改和遗忘解决方法
                                    bijian1013
Welogic
                                    
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 
一.修改Console密码 
        打开weblogic控制台，安全领域 --> myrealm -->&n
    
                                
    • 
                                
  • IllegalStateException: Cannot forward a response that is already committed
                                    Cwind
javaServlets
                                    
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。   示例代码：   
protected void doPost() {
    if (someCondition) {
        sendRedirect();
    }
    forward(); // Thi
    
                                
    • 
                                
  • 基于流的装饰设计模式
                                    木zi_鸣
设计模式
                                    
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 
自定义的类成为装饰类 
 
模仿BufferedReader，对Reader进行包装，体现装饰设计模式 
 
装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 
装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 
 
装饰类因为增强已有对象，具备的功能该
    
                                
    • 
                                
  • Linux中的uniq命令
                                    被触发
linux
                                    
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 
AD： 
uniq [选项] 文件 
说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
    
                                
    • 
                                
  • 正则表达式Pattern
                                    肆无忌惮_
Pattern
                                    
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。 
  
例如，我们需要对QQ号码格式进行检验 
规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} 
&nbs
    
                                
    • 
                                
  • Oracle高级查询之OVER (PARTITION BY ..)
                                    知了ing
oraclesql
                                    
    一、rank()/dense_rank() over(partition by ...order by ...) 
 
现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： 
 
 select e.ename, e.job, e.sal, e.deptno  
  from scott.emp e,  
       (se
    
                                
    • 
                                
  • Python调试
                                    矮蛋蛋
pythonpdb
                                    
    原文地址： 
http://blog.csdn.net/xuyuefei1988/article/details/19399137 
1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： 
 
IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： 
 
http://www.ibm.com/d
    
                                
    • 
                                
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题
                                    alleni123
webservice
                                    
    今天在客户端调用方法 
NodeStatus status=iservice.getNodeStatus(). 
 
结果NodeStatus的属性都是null。 
 
进行debug之后，发现服务器端返回的确实是有值的对象。 
 
后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 
本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
    
                                
    • 
                                
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针
                                    百合不是茶

                                    
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作： 
  
定义一个指针p来指向a的地址（&是地址符号）： 
        
    
                                
    • 
                                
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log”
                                    bijian1013
eclipse
                                    
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： 
 
!ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 
!MESSAGE Application error 
!STACK 1 
java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
    
                                
    • 
                                
  • spring aop实例annotation方法实现
                                    bijian1013
javaspringAOPannotation
                                    
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut 
AdviceMethods.jav
    
                                
    • 
                                
  • [Velocity一]Velocity语法基础入门
                                    bit1129
velocity
                                    
    用户和开发人员参考文档 
http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html 
  注释 
1.行级注释## 
2.多行注释#*  *# 
  变量定义 
使用$开头的字符串是变量定义，例如$var1, $var2, 
  赋值 
使用#set为变量赋值，例
    
                                
    • 
                                
  • 【Kafka十一】关于Kafka的副本管理
                                    bit1129
kafka
                                    
    1. 关于request.required.acks 
  
request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 
0表示即不进行确认即返回。 
1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 
-1表示根据指定的最少Partition确认后才返回，这个在 
  
Th
    
                                
    • 
                                
  • lua统计nginx内部变量数据
                                    ronin47
lua nginx　 统计
                                    
    server {
    listen 80;
    server_name photo.domain.com;
    location /{set $str $uri;
        content_by_lua '
            local url = ngx.var.uri
            local res = ngx.location.capture(
    
                                
    • 
                                
  • java-11.二叉树中节点的最大距离
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;


public class MaxLenInBinTree {

	/*
	 a.			1
	 		   /  \
	 		  2    3
	 		 / \  / \
	 		4   5 6  7
	 	max=4	pass "root"
	 
    
                                
    • 
                                
  • Netty源码学习-ReadTimeoutHandler
                                    bylijinnan
javanetty
                                    
     
ReadTimeoutHandler的实现思路： 
开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 
这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 
 
 

private final ChannelHandler timeoutHandler =
	new ReadTim
    
                                
    • 
                                
  • jquery验证上传文件样式及大小(好用)
                                    cngolon
文件上传jquery验证
                                    
    <!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <script src="jquery1.8/jquery-1.8.0.
    
                                
    • 
                                
  • 浏览器兼容【转】
                                    cuishikuan
css浏览器IE
                                    
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 
 
问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 
 
碰到频率:100% 
 
解决方案：CSS里    *{margin:0;padding:0;} 
 
备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
    
                                
    • 
                                
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数
                                    daizj
shell$#$?特殊变量
                                    
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码：   
 
  $echo $$  
   
运行结果 
29949 
   特殊变量列表   变量 含义   $0 当前脚本的文件名   $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
    
                                
    • 
                                
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID!
                                    dcj3sjt126com
unix
                                    
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 
 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
    
                                
    • 
                                
  • android Activity间List传值
                                    dcj3sjt126com
Activity
                                    
    第一个Activity： 
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
    
                                
    • 
                                
  • tomcat 设置java虚拟机内存
                                    eksliang
tomcat 内存设置
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 
http://eksliang.iteye.com/ 
常见的内存溢出有以下两种: 
java.lang.OutOfMemoryError: PermGen space  
java.lang.OutOfMemoryError: Java heap space 
  
------------
    
                                
    • 
                                
  • Android 数据库事务处理
                                    gqdy365
android
                                    
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
    
                                
    • 
                                
  • Java 打开浏览器
                                    hw1287789687
打开网址open浏览器open browser打开url打开浏览器
                                    
    使用java 语言如何打开浏览器呢? 
我们先研究下在cmd窗口中,如何打开网址 
使用IE 打开 
D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 
使用火狐打开 
D:\software\bin>cmd /c start firefox http://hw1287789
    
                                
    • 
                                
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件
                                    justjavac
chromeGooglegoogle apichrome插件
                                    
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 
 
 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
    
                                
    • 
                                
  • 进程VS.线程
                                    m635674608
线程
                                    
    资料来源： 
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 
多进程模式最大
    
                                
    • 
                                
  • Linux下安装MemCached
                                    字符串
memcached
                                    
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
    
                                
    • 
                                
  • java设计模式之--jdk动态代理（实现aop编程）
                                    Supanccy2013
javaDAO设计模式AOP
                                    
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 
&
    
                                
    • 
                                
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持
                                    wiselyman
spring 4
                                    
    2.1 默认方法(default method) 
 
 java8引入了一个default medthod; 
 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 
 使用default关键字 
 Spring 4.2支持加载在默认方法里声明的bean 
  
2.2 
 
 将要被声明成bean的类 
  
public class DemoService {
    
    
                                
    • 
                

            

        

    




    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他