JAVA

首先我們介紹一下一顆 m 階B-tree的特性，那么這個 m 階是怎么定義的呢？這里我們以一個節點能擁有的最大子節點數來表示這顆樹的階數。舉個例子，如果一個節點最多有 n 個key，那么這個節點最多就會有 n+1 個子節點，這棵樹就叫做 n+1（m=n+1）階樹。一顆 m 階B-tree包括以下5條特性：

1. 每個節點最多有 m 個子節點
2. 除根節點和葉子節點，其它每個節點至少有 [m/2] （向上取整的意思）個子節點
3. 若根節點不是葉子節點，則其至少有2個子節點
4. 所有NULL節點到根節點的高度都一樣
5. 除根節點外，其它節點都包含 n 個key，其中 [m/2] -1 <= n <= m-1

這些特性可能看著不太好理解，下面我們會介紹B-tree的插入，在插入節點的過程中我們就會慢慢理解這些特性了。B-tree的插入比較簡單，就是一個節點至下而上的分裂過程。下面我們具體以一顆4階樹來展示B-tree的插入過程。

首先我們 插入 200，300，400，沒有什么問題，直接插入就好。

| 200 | 300 | 400 |

現在我們接著插入500，這個時候我們發現有點問題，根據定義及特性1我們知道一顆4階B-tree的每個節點最多只能有3個key，插入500后這個節點就有4個key了。

| 200 | 300 | 400 | 500 |

這個時候我們就需要分裂，將中間的key上移到父節點，左邊的作為左節點，右邊的作為右節點，如下圖所示：

通過整個的插入過程我們也會發現，B-tree和二叉樹的一個顯著的區別就是，B-tree是從下往上生長，而二叉樹是從上往下生長的?，F在我們想想特性2和特性5是為什么？首先我們知道子節點的個數是等于key的數目+1，然后一個節點達到m個key后就會分裂，所以分裂后的節點最少能得到 m/2 - 1個key 。為啥還要減一呢？因為還要拿一個作為父節點。所以這個節點最少回擁有 m/2 - 1 + 1 = m/2 個子節點。同樣得到特性5，因為最少有m/2個子節點，所以最少就含有m/2-1個key，m 階樹，每個節點存到了m個key就會分裂，所以最多就有 m-1個key。

根據以上特性我們能推出一棵含有N個總關鍵字數的m階的B-tree樹的最大高度h的值,

樹的高度h: 1， 2， 3 ， 4 ，.......... ， h

節點個數s: 1， 2， 2*(m/2)， 2*(m/2)(m/2)， ........ ，2*(m/2)的h-2次方

s = 1 + 2(1 - )/(1- (m/2))

N = 1 + s * ((m/2) - 1) = 2 * () - 1

h = log┌m/2┐((N+1)/2 )+1

2：為什么btree/b+tree 為常用數據庫索引結構？

上文說過，紅黑樹等數據結構也可以用來實現索引，但是文件系統及數據庫系統普遍采用B-/+Tree作為索引結構，這一節將結合計算機組成原理相關知識討論B-/+Tree作為索引的理論基礎。

一般來說，索引本身也很大，不可能全部存儲在內存中，因此索引往往以索引文件的形式存儲的磁盤上。這樣的話，索引查找過程中就要產生磁盤I/O消耗，相對于內存存取，I/O存取的消耗要高幾個數量級，所以評價一個數據結構作為索引的優劣最重要的指標就是在查找過程中磁盤I/O操作次數的漸進復雜度。換句話說，索引的結構組織要盡量減少查找過程中磁盤I/O的存取次數。下面先介紹內存和磁盤存取原理，然后再結合這些原理分析B-/+Tree作為索引的效率。

主存存取原理

目前計算機使用的主存基本都是隨機讀寫存儲器（RAM），現代RAM的結構和存取原理比較復雜，這里本文拋卻具體差別，抽象出一個十分簡單的存取模型來說明RAM的工作原理。

圖5

從抽象角度看，主存是一系列的存儲單元組成的矩陣，每個存儲單元存儲固定大小的數據。每個存儲單元有唯一的地址，現代主存的編址規則比較復雜，這里將其簡化成一個二維地址：通過一個行地址和一個列地址可以唯一定位到一個存儲單元。圖5展示了一個4 x 4的主存模型。

主存的存取過程如下：

當系統需要讀取主存時，則將地址信號放到地址總線上傳給主存，主存讀到地址信號后，解析信號并定位到指定存儲單元，然后將此存儲單元數據放到數據總線上，供其它部件讀取。

寫主存的過程類似，系統將要寫入單元地址和數據分別放在地址總線和數據總線上，主存讀取兩個總線的內容，做相應的寫操作。

這里可以看出，主存存取的時間僅與存取次數呈線性關系，因為不存在機械操作，兩次存取的數據的“距離”不會對時間有任何影響，例如，先取A0再取A1和先取A0再取D3的時間消耗是一樣的。

磁盤存取原理

上文說過，索引一般以文件形式存儲在磁盤上，索引檢索需要磁盤I/O操作。與主存不同，磁盤I/O存在機械運動耗費，因此磁盤I/O的時間消耗是巨大的。

圖6是磁盤的整體結構示意圖。

圖6

一個磁盤由大小相同且同軸的圓形盤片組成，磁盤可以轉動（各個磁盤必須同步轉動）。在磁盤的一側有磁頭支架，磁頭支架固定了一組磁頭，每個磁頭負責存取一個磁盤的內容。磁頭不能轉動，但是可以沿磁盤半徑方向運動（實際是斜切向運動），每個磁頭同一時刻也必須是同軸的，即從正上方向下看，所有磁頭任何時候都是重疊的（不過目前已經有多磁頭獨立技術，可不受此限制）。

圖7是磁盤結構的示意圖。

圖7

盤片被劃分成一系列同心環，圓心是盤片中心，每個同心環叫做一個磁道，所有半徑相同的磁道組成一個柱面。磁道被沿半徑線劃分成一個個小的段，每個段叫做一個扇區，每個扇區是磁盤的最小存儲單元。為了簡單起見，我們下面假設磁盤只有一個盤片和一個磁頭。

當需要從磁盤讀取數據時，系統會將數據邏輯地址傳給磁盤，磁盤的控制電路按照尋址邏輯將邏輯地址翻譯成物理地址，即確定要讀的數據在哪個磁道，哪個扇區。為了讀取這個扇區的數據，需要將磁頭放到這個扇區上方，為了實現這一點，磁頭需要移動對準相應磁道，這個過程叫做尋道，所耗費時間叫做尋道時間，然后磁盤旋轉將目標扇區旋轉到磁頭下，這個過程耗費的時間叫做旋轉時間。

局部性原理與磁盤預讀

由于存儲介質的特性，磁盤本身存取就比主存慢很多，再加上機械運動耗費，磁盤的存取速度往往是主存的幾百分分之一，因此為了提高效率，要盡量減少磁盤I/O。為了達到這個目的，磁盤往往不是嚴格按需讀取，而是每次都會預讀，即使只需要一個字節，磁盤也會從這個位置開始，順序向后讀取一定長度的數據放入內存。這樣做的理論依據是計算機科學中著名的局部性原理：

當一個數據被用到時，其附近的數據也通常會馬上被使用。

程序運行期間所需要的數據通常比較集中。

由于磁盤順序讀取的效率很高（不需要尋道時間，只需很少的旋轉時間），因此對于具有局部性的程序來說，預讀可以提高I/O效率。

預讀的長度一般為頁（page）的整倍數。頁是計算機管理存儲器的邏輯塊，硬件及操作系統往往將主存和磁盤存儲區分割為連續的大小相等的塊，每個存儲塊稱為一頁（在許多操作系統中，頁得大小通常為4k），主存和磁盤以頁為單位交換數據。當程序要讀取的數據不在主存中時，會觸發一個缺頁異常，此時系統會向磁盤發出讀盤信號，磁盤會找到數據的起始位置并向后連續讀取一頁或幾頁載入內存中，然后異常返回，程序繼續運行。

B-/+Tree索引的性能分析

到這里終于可以分析B-/+Tree索引的性能了。

上文說過一般使用磁盤I/O次數評價索引結構的優劣。先從B-Tree分析，根據B-Tree的定義，可知檢索一次最多需要訪問h個節點。數據庫系統的設計者巧妙利用了磁盤預讀原理，將一個節點的大小設為等于一個頁，這樣每個節點只需要一次I/O就可以完全載入。為了達到這個目的，在實際實現B- Tree還需要使用如下技巧：

每次新建節點時，直接申請一個頁的空間，這樣就保證一個節點物理上也存儲在一個頁里，加之計算機存儲分配都是按頁對齊的，就實現了一個node只需一次I/O。

B-Tree中一次檢索最多需要h-1次I/O（根節點常駐內存），漸進復雜度為O(h)=O(logdN)。一般實際應用中，出度d是非常大的數字，通常超過100，因此h非常?。ㄍǔ２怀^3）。

綜上所述，用B-Tree作為索引結構效率是非常高的。

而紅黑樹這種結構，h明顯要深的多。由于邏輯上很近的節點（父子）物理上可能很遠，無法利用局部性，所以紅黑樹的I/O漸進復雜度也為O(h)，效率明顯比B-Tree差很多。

上文還說過，B+Tree更適合外存索引，原因和內節點出度d有關。從上面分析可以看到，d越大索引的性能越好，而出度的上限取決于節點內key和data的大小：

dmax = floor(pagesize / (keysize + datasize + pointsize))  (pagesize – dmax >= pointsize)

或

dmax = floor(pagesize / (keysize + datasize + pointsize)) - 1  (pagesize – dmax < pointsize)

floor表示向下取整。由于B+Tree內節點去掉了data域，因此可以擁有更大的出度，擁有更好的性能。

這一章從理論角度討論了與索引相關的數據結構與算法問題，下一章將討論B+Tree是如何具體實現為MySQL中索引，同時將結合MyISAM和InnDB存儲引擎介紹非聚集索引和聚集索引兩種不同的索引實現形式。

1、不同的tomcat的啟動文件startup.sh 中要指定各自的CATALINA_HOME和CATALINA_BASE這兩個環境變量。

2、不同的tomcat啟動和關閉監聽不同的端口

很多人喜歡把CATALINA_HOME和CATALINA_BASE配置到系統環境變量中去，我們不這么做，我們要做的只是把JDK及CLASSPATH配置到環境變量中去即可，因為這個可以通用。
CATALINA_HOME和CATALINA_BASE的區別。簡單的說，CATALINA_HOME是Tomcat的安裝目 錄，CATALINA_BASE是Tomcat的工作目錄。如果我們想要運行Tomcat的 多個實例，但是不想安裝多個Tomcat軟件副本。那么我們可以配置多個工作 目錄，每個運行實例獨占一個工作目錄，但是共享同一個安裝目錄

下面講具體的配置方法。

找到Tomcat的startup.sh文件，打開進行編輯。

在文件的開始位置，可以在一大堆注釋的后面，加入
export CATALINA_BASE=/usr/ratest/apache-tomcat-7.0.16
export CATALINA_HOME=/usr/ratest/apache-tomcat-7.0.16

/usr/ratest/apache-tomcat-7.0.16這個就是tomcat的安裝文件夾位置，不同的tomcat指定相應的文件夾即可。

注意，這兩句話一定要在exec “$PRGDIR”/”$EXECUTABLE” start “$@”這句話的前面，我們放在文件的開始位置了，所以，就可以不考慮了。

然后就是要修改shutdown.sh文件，同樣在頭部加入上面的兩行即可，也要在exec “$PRGDIR”/”$EXECUTABLE” stop “$@”的前面。

好了，解決了第一個問題，下面說第二個問題的解決方法。

找到并打開server.xml文件，里面有諸如8080，8009，8443等等端口配置，統一給這些數字加上100，或者1000或者其他什么數字，只要是不跟其他Tomcat或者當前linux上其他服務的端口重復即可。

現在進入Tomcat的bin文件夾，運行./startup.sh看看是不是可以啟動多個了。

很多tomcat進程退出（或者進程假死），都是由于頻繁的拋出OutOfMemeoryError導致的。

為了讓tomcat退出前或者發生OutOfMemeoryError時自動dump堆棧信息，方便事后排查問題，我們可以做如下操作：

1、 在tomcat啟動參數中加入兩個參數 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/export/home/tomcat/domains/server2/oom.hprof

2、 重啟tomcat

參數說明
（1）-XX:+HeapDumpOnOutOfMemoryError 表示當JVM發生OOM時，自動生成DUMP文件。
（2）-XX:HeapDumpPath=存儲文件/目錄 表示生成DUMP文件的路徑

想從JAVA轉到obj-c，看了些基礎的東西，感覺很奇怪，可能不太習慣，在網上看到一個不錯文章有助理解obj-c的一些核心機制。

SomeClass.h
@interface SomeClass : NSObject{
}
-(void) print;
@end 

#import "SomeClass.h"
 
@interface SomeClass (Hello)
-(void)hello;
@end

#import "SomeClass+Hello.h"
@implementationSomeClass (Hello)
-(void)hello{
    NSLog (@"name：%@ ", @"Jacky");
}
@end 

#import "SomeClass+Hello.h"
 
SomeClass * sc =[[SomeClass alloc] init];
[sc hello] 

@protocol ProcessDataDelegate <NSObject>
@required
- (void) processSuccessful: (BOOL)success;

@optional
- (id) submitOrder: (NSNumber *) orderid;
@end

@interface TestAppDelegate : NSObject<ProcessDataDelegate>;

@end

@implementation TestAppDelegate

- (void) processSuccessful: (BOOL)success{
    if (success) {
        NSLog(@"成功");
    }else {
        NSLog(@"失敗");
    }
}

@end 

@protocol A
     -(void)methodA;
@end
@protocol B <A>
     -(void)methodB;
@end

[obj conformsToProtocol:@protocol(ProcessDataDelegate)] 

首先在web工程src目錄下新建一個database.properties 文件
內容如下：

user=root
password=root
databaseType=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.2.232:3306/oa? seUnicode=true&amp;characterEncoding=UTF8&amp;zeroDateTimeBehavior=convertToNull

 這里的內容隨自己的合適而變化，這里不多說了；

在新建一個讀取.properties文件新類：

package com.junhai.tamsys.util;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class DatabaseConfigure {
 private Properties property;
 private FileInputStream inputFile;
 private FileOutputStream outputFile;

 public DatabaseConfigure() {
  property = new Properties();
 }

 public DatabaseConfigure(String filePath) {
  property = new Properties();
  try {
   inputFile = new FileInputStream(filePath);
   property.load(inputFile);
   inputFile.close();
  } catch (FileNotFoundException e) {
   System.out.println("讀取屬性文件--->失??！- 原因：文件路徑錯誤或者文件不存在");
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 /*
  * 重載函數，得到key的值 @param key 取得其值的鍵 @return key的值
  */
 public String getValue(String key) {
  if (property.containsKey(key)) {
   return property.getProperty(key);

  } else
   return "";
 }

 /*
  * 重載函數，得到key的值
  *
  * @param fileName propertys文件的路徑+文件名 @param key 取得其值的鍵 @return key的值
  */
 public String getValue(String fileName, String key) {
  try {
   String value = "";
   inputFile = new FileInputStream(fileName);
   property.load(inputFile);
   inputFile.close();
   if (property.containsKey(key)) {
    value = property.getProperty(key);
    return value;
   } else
    return value;
  } catch (FileNotFoundException e) {
   e.printStackTrace();
   return "";
  } catch (IOException e) {
   e.printStackTrace();
   return "";
  } catch (Exception ex) {
   ex.printStackTrace();
   return "";
  }
 }

 /*
  * 清除properties文件中所有的key和其值
  */
 public void clear() {
  property.clear();
 }

 /*
  * 改變或添加一個key的值，當key存在于properties文件中時該key的值被value所代替， 當key不存在時，該key的值是value
  * @param key 要存入的鍵 @param value 要存入的值
  */
 public void setValue(String key, String value) {
  property.setProperty(key, value);
 }

 /*
  * 將更改后的文件數據存入指定的文件中，該文件可以事先不存在。 @param fileName 文件路徑+文件名稱 @param
  * description 對該文件的描述
  */
 public void saveFile(String fileName, String description) {
  try {
   outputFile = new FileOutputStream(fileName);
   property.store(outputFile, description);
   outputFile.close();
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 public static void main(String[] args) {
  DatabaseConfigure test=new DatabaseConfigure("./src/database.properties");
  System.out.println(test.getValue("user"));
  System.out.println(test.getValue("databaseType")+";"+test.getValue("url"));
  
 }
}

Hiberante3 一級緩存總結

1．             Session 級別的緩存，它同session邦定。它的生命周期和session相同。Session消毀，它也同時消毀；管理一級緩存，一級緩存無法取消，用兩個方法管理，clear(),evict()

2．             兩個session 不能共享一級緩存，因它會伴隨session的生命周期的創建和消毀；

3．             Session緩存是實體級別的緩存，就是只有在查詢對象級別的時候才使用，如果

使用HQL和SQL是查詢屬性級別的，是不使用一級緩存的！切記?。。?！

4 .  iterate 查詢使用緩存，會發出查詢Id的SQL和HQL語句，但不會發出查實體的，

它查詢完會把相應的實體放到緩存里邊，一些實體查詢如果緩存里邊有，就從緩存中查詢，但還是會發出查詢id的SQL和HQL語句。如果緩存中沒有它會數據庫中查詢，然后將查詢到的實體一個一個放到緩存中去，所以會有N+1問題出現。

5 . List()和iterate 查詢區別：

使用iterate,list查詢實體對象*N+1問題，在默認情況下，使用query.iterate查詢，有可以能出現N+1問題

所謂的N+1是在查詢的時候發出了N+1條sql語句1:首先發出一條查詢對象id列表的sqlN:

根據id列表到緩存中查詢，如果緩存中不存在與之匹配的數據，那么會根據id發出相應的sql語句list和iterate的區別？

list每次都會發出sql語句，list會向緩存中放入數據，而不利用緩存中的數據

iterate：在默認情況下iterate利用緩存數據，但如果緩存中不存在數據有可以能出現N+1問題

6．Get()和load(),iterate方法都會使用一級緩存，

7.hiberate3 session 存儲過程如下：

       例如 object 對象

       Session.save(object);

       這時候不會把數據放到數據庫，會先放到session緩存中去，數據庫中沒有相應記錄，session.flush();才發SQL和HQL語句，數據庫中有了相應記錄，

       但是數據庫用select查不到，這是跟數據庫事物級別有關系，（這里在說下數據庫的事務隔離級別一共四種如下：）
    數據庫隔離級別：
        隔離級別                       是否存在臟讀  是否存在不可重復讀     是否存在幻讀；
    Read UnCommited(未提交讀)               Y            Y                     Y
    Read Commited (提交讀 oraclel默認)      N            Y                     Y
    Repeatable Read(不可重復讀（Msql默認）)  N            N                     Y 
    Serializable(使用很少)                  N            N                     N
    

       Session.beginTrransaction().commit();

       事物提交后可以查詢到了。

Session.flush()語句但是為什么不寫呢，因為commit()會默認調用flush();

Hiberante3 二級緩存總結

1．Hibernate3的（sessionFactory）二級緩存和session級別的緩存一樣都只對實體對象做緩存，不對屬性級別的查詢做緩存；二級緩存的生命周期和sessionFactory的生命周期是一樣的，sessionFactory可以管理二級緩存；

2．sessionFactory級別的緩存，需要手動配置；所有的session可以共享sessionFactory 級別的緩存；（一般把一些不經常變化的實體對象放到sessionFactory級別的緩存中，適合放不經常變化的實體對象。）

3．Hiberante3二級緩存的配置和使用方法如下：

1． 必須把ehcache.jar包導入，然后到Hibernate3.2的etc文件下把ehcache.xml復制到工程src目錄下（ehcache.xml里邊的參數里邊有詳細英文說明）；

（說明：ehcache.jar是第三方法的緩存產品，hiberante只是把它做了集成，還有好多第三方hibernate集成的緩存產品，相關說明請查閱hiberante3開發手冊；ehcache支持分布應用的（這個和Hibernate3.2開發手冊有出入，經過官網查證確實支持了），如果有分布式需求，請換成支持分布式的二級緩存產品，hiberate3開發手冊都有相頭說明。配置方法都類似）；

4．Hibernate3的二級緩存默認是開起的，也可以指定開起。在hibernate.cfg.xml 文件下配置如下：

*修改hibernate.cfg.xml文件，開戶二級緩存；

                     <property name=”hibernate.cache.use_second_level_cache”>true</property>

                     *指定二級緩存產品的提供商；

<property name=”hibernate.cache.provider_class”> org.hibernate.cache.EhCacheProvider

</property>

要讓那些實體使用二級緩存，在hibernate.cfg.xml配置文件中加入：

<!—

讓這個實體用二級緩存 也可以在實體中映射文件去配置即：

<cache usage="read-only"/>

-->

<class-cache class=”com.zzz.hibernate.ClassT” usage=”read-only”/>

Read-only一般使用這個策略，其它的hibernate3開發手冊中也有詳細介紹；

CacheMode去hibernate3開發手冊中搜索這個關鍵字，可以找到一級緩存和二級緩存交互使用的問題；

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

 <!-- 配置spring監聽器和上下文變量 -->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/applicationContext-*.xml</param-value>
 </context-param>

 <listener>
  <listener-class>
   org.springframework.web.context.ContextLoaderListener
  </listener-class>
 </listener>
 <!-- spring end -->

<!-- 配置字符過濾器-->
 <filter>
  <filter-name>encodingFilter</filter-name>
  <filter-class>
   org.springframework.web.filter.CharacterEncodingFilter
  </filter-class>
  <init-param>
   <param-name>encoding</param-name>
   <param-value>GBK</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>encodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

 <!--讓spring來過濾管理Hiberante中的session-->
 <filter>
  <filter-name>lazyLoadingFilter</filter-name>
  <filter-class>
   org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  </filter-class>
 </filter>

 <!-- spring end -->

 <!-- 增加struts2所需要的過濾器,以便在服務器啟動時,攔截URL請求 -->
 <filter>
  <filter-name>struts2</filter-name>
  <filter-class>
   org.apache.struts2.dispatcher.FilterDispatcher
  </filter-class>
 </filter>

 <filter-mapping>
  <filter-name>lazyLoadingFilter</filter-name>
  <url-pattern>*.action</url-pattern>
 </filter-mapping>

 <filter-mapping>
  <filter-name>struts2</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
  </web-app>