/***
*** [关于connectString服务器地址配置]
*** 格式: 192.168.1.1:2181,192.168.1.2:2181,192.168.1.3:2181
*** 这个地址配置有多个ip:port之间逗号分隔,底层操作:
*** ConnectStringParser connectStringParser =  new ConnectStringParser(“192.168.1.1:2181,192.168.1.2:2181,192.168.1.3:2181”);
*** 这个类主要就是解析传入地址列表字符串，将其它保存在一个ArrayList中
*** ArrayList<InetSocketAddress> serverAddresses = new ArrayList<InetSocketAddress>();
*** 接下去，这个地址列表会被进一步封装成StaticHostProvider对象，并且在运行过程中，一直是这个对象来维护整个地址列表。
*** ZK客户端将所有Server保存在一个List中，然后随机打乱(这个随机过程是一次性的)，并且形成一个环，具体使用的时候，从0号位开始一个一个使用。
*** 因此，Server地址能够重复配置，这样能够弥补客户端无法设置Server权重的缺陷，但是也会加大风险。
*** 
*** [客户端和服务端会话说明]
*** ZooKeeper中，客户端和服务端建立连接后，会话随之建立，生成一个全局唯一的会话ID(Session ID)。
*** 服务器和客户端之间维持的是一个长连接，在SESSION_TIMEOUT时间内，服务器会确定客户端是否正常连接(客户端会定时向服务器发送heart_beat，服务器重置下次SESSION_TIMEOUT时间)。
*** 因此，在正常情况下，Session一直有效，并且ZK集群所有机器上都保存这个Session信息。
*** 在出现网络或其它问题情况下（例如客户端所连接的那台ZK机器挂了，或是其它原因的网络闪断）,客户端与当前连接的那台服务器之间连接断了,这个时候客户端会主动在地址列表（实例化ZK对象的时候传入构造方法的那个参数connectString）中选择新的地址进行连接。
***
*** [会话时间]
*** 客户端并不是可以随意设置这个会话超时时间，在ZK服务器端对会话超时时间是有限制的，主要是minSessionTimeout和maxSessionTimeout这两个参数设置的。
*** 如果客户端设置的超时时间不在这个范围，那么会被强制设置为最大或最小时间。 默认的Session超时时间是在2 * tickTime ~ 20 * tickTime
*** @param connectString  Zookeeper服务地址
*** @param sessionTimeout Zookeeper连接超时时间
***/

public void connectionZookeeper(String connectString, int sessionTimeout){
    this.releaseConnection();
    try {
       // ZK客户端允许我们将ZK服务器的所有地址都配置在这里
       zk = new ZooKeeper(connectString, sessionTimeout, this );
       // 使用CountDownLatch.await()的线程（当前线程）阻塞直到所有其它拥有CountDownLatch的线程执行完毕（countDown()结果为0）
       connectedSemaphore.await();          
    } catch ( InterruptedException e  ) {
       LOG.error("连接创建失败，发生 InterruptedException , e " + e.getMessage(), e);         
    } catch ( IOException e  ) {
       LOG.error( "连接创建失败，发生 IOException , e " + e.getMessage(), e  );          
    }
}

/*
* 创建zNode节点, String create(path<节点路径>, data[]<节点内容>, List(ACL访问控制列表), CreateMode<zNode创建类型>)
*    节点创建类型(CreateMode)
*    1、PERSISTENT:持久化节点
*    2、PERSISTENT_SEQUENTIAL:顺序自动编号持久化节点，这种节点会根据当前已存在的节点数自动加 1
*    3、EPHEMERAL:临时节点客户端,session超时这类节点就会被自动删除
*    4、EPHEMERAL_SEQUENTIAL:临时自动编号节点
* @param path zNode节点路径
* @param data zNode数据内容
* @return 创建成功返回true, 反之返回false.
*/

public boolean createPath( String path, String data  ) {
    try {
                    String zkPath =  this.zk.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                    LOG.info( "节点创建成功, Path: " + zkPath + ", content: " + data  );
                    return true;
                
    } catch ( KeeperException e  ) {
                    LOG.error( "节点创建失败, 发生KeeperException! path: " + path + ", data:" + data
                                                 + ", errMsg:" + e.getMessage(), e );
                
    } catch ( InterruptedException e  ) {
                    LOG.error( "节点创建失败, 发生 InterruptedException! path: " + path + ", data:" + data
                                                 + ", errMsg:" + e.getMessage(), e );
                
    }
            return false;
        
}

/**
* <p>删除一个zMode节点, void delete(path<节点路径>, stat<数据版本号>)</p><br/>
* <pre>
*     说明
*     1、版本号不一致,无法进行数据删除操作.
*     2、如果版本号与znode的版本号不一致,将无法删除,是一种乐观加锁机制;如果将版本号设置为-1,不会去检测版本,直接删除.
* </pre>
* @param path zNode节点路径
* @return 删除成功返回true,反之返回false.
*/

public boolean deletePath( String path  ){
    try {
                    this.zk.delete(path,-1);
                    LOG.info( "节点删除成功, Path: " + path );
                    return true;
                
    } catch ( KeeperException e  ) {
                    LOG.error( "节点删除失败, 发生KeeperException! path: " + path
                                                 + ", errMsg:" + e.getMessage(), e );
                
    } catch ( InterruptedException e  ) {
                    LOG.error( "节点删除失败, 发生 InterruptedException! path: " + path
                                                 + ", errMsg:" + e.getMessage(), e );
                
    }
            return false;
        
}

$ mvn archetype:generate 
-DgroupId=com.mycompany.helloworld 
-DartifactId=helloworld 
-Dpackage=com.mycompany.helloworld 
-Dversion=1.0-SNAPSHOT

$ mvn clean compile   
$ mvn clean test   
$ mvn clean package  
$ mvn clean install

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion> 

     <groupId>com.mycompany.helloworld</groupId> 
     <artifactId>helloworld</artifactId> 
     <version>1.0-SNAPSHOT</version> 
     <packaging>jar</packaging> 

     <name>helloworld</name> 
     <url>http://maven.apache.org</url> 

     <properties> 
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
     </properties> 

     <dependencies>
       <dependency> 
         <groupId>junit</groupId> 
         <artifactId>junit</artifactId> 
         <version>3.8.1</version> 
         <scope>test</scope> 
       </dependency> 
     </dependencies> 
    </project>

JAVA_OPTS="$JAVA_OPTS  
 -Djava.rmi.server.hostname=nts3.photo.163.org  
 -Dcom.sun.management.jmxremote.port=8950  
 -Dcom.sun.management.jmxremote.authenticate=false  
 -Dcom.sun.management.jmxremote.ssl=false"  

//双向循环链表的头结点，整个LinkedHashMap中只有一个header，
//（此链表不同于HashMap里面的那个next链表）
//它将哈希表中所有的Entry贯穿起来，header中不保存key-value对，只保存前后节点的引用
   private transient Entry<K,V> header;

//双向链表中元素排序规则的标志位。
//accessOrder为false，表示按插入顺序排序
//accessOrder为true，表示按访问顺序排序
    private final boolean accessOrder;


 /** 
 * LinkedHashMap的Entry元素。 
 * 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。 
 */  
private static class Entry<K,V> extends HashMap.Entry<K,V> {  
    Entry<K,V> before, after;  
    ……  //Entry类涉及到的方法，下面会继续分析
}  

// 构造方法1，构造一个指定初始容量和加载因子的、按照插入顺序的LinkedList
//加载因子取默认的0.75f  

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

// 构造方法2，构造一个指定初始容量的LinkedHashMap，取得键值对的顺序是插入顺序
//加载因子取默认的0.75f  

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

// 构造方法3，用默认的初始化容量和加载因子创建一个LinkedHashMap，取得键值对的顺序是插入顺序
//加载因子取默认的0.75f  

public LinkedHashMap() {
    super();
    accessOrder = false;
}

// 构造方法4，通过传入的map创建一个LinkedHashMap，容量为默认容量（16）和
//(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，加载因子为默认值0.75

public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super(m);
    accessOrder = false;
}

// 构造方法5，根据指定容量、加载因子和指定链表中的元素排序的规则  创建一个LinkedHashMap
public LinkedHashMap(int initialCapacity,
             float loadFactor,
                         boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

void init() {
    header = new Entry<K,V>(-1, null, null, null);
    header.before = header.after = header;
}

	//覆写HashMap中的addEntry方法，LinkedHashmap并没有覆写HashMap中的put方法，
	//而是覆写了put方法所调用的addEntry方法和recordAccess方法，
	//put方法在插入的key已存在的情况下，会调用recordAccess方法，
	//在插入的key不存在的情况下，要调用addEntry插入新的Entry
void addEntry(int hash, K key, V value, int bucketIndex) {
	//创建新的Entry，并插入到LinkedHashMap中
    createEntry(hash, key, value, bucketIndex);

    //双向链表的第一个有效节点（header后的那个节点）为近期最少使用的节点
    Entry<K,V> eldest = header.after;
    //如果有必要，则删除掉该近期最少使用的节点，
	//这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。
    if (removeEldestEntry(eldest)) {
        removeEntryForKey(eldest.key);
    } else {
    	//超过阈值，扩容到原来的2倍
        if (size >= threshold)
            resize(2 * table.length);
    }
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMap.Entry<K,V> old = table[bucketIndex];
    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
    table[bucketIndex] = e;
    // 调用元素的addBrefore方法，将元素加入到哈希、双向链接列表。
    //每次插入Entry时，都将其移到双向链表的尾部，
	//这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素，
	//同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾，符合LRU算法的实现
    e.addBefore(header);
    size++;
}
//双向循环立链表中，将当前的Entry插入到existingEntry的前面
private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

//该方法默认返回false，我们一般在用LinkedHashMap实现LRU算法时，
//要覆写该方法，一般的实现是，当设定的内存（这里指节点个数）达到最大值时，返回true，
//这样put新的Entry（该Entry的key在哈希表中没有已经存在）时，
//就会调用removeEntryForKey方法，将最近最少使用的节点删除（head后面的那个节点，实际上是最近没有使用）。
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
}

	//覆写HashMap中的get方法，通过getEntry方法获取Entry对象。
	//注意这里的recordAccess方法，
	//如果链表中元素的排序规则是按照插入的先后顺序排序的话，该方法什么也不做，
	//如果链表中元素的排序规则是按照访问的先后顺序排序的话，则将e移到链表的末尾处。
public V get(Object key) {
    // 调用父类HashMap的getEntry()方法，取得要查找的元素。
    Entry<K,V> e = (Entry<K,V>)getEntry(key);
    if (e == null)
        return null;
    // 记录访问顺序。
    e.recordAccess(this);
    return e.value;
}
//覆写HashMap中的recordAccess方法（HashMap中该方法为空），
//当调用父类的put方法，在发现插入的key已经存在时，会调用该方法，
//调用LinkedHashmap覆写的get方法时，也会调用到该方法，
//该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部，
//accessOrder为true时，get方法会调用recordAccess方法
//put方法在覆盖key-value对时也会调用recordAccess方法
//它们导致Entry最近使用，因此将其移到双向链表的末尾
void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
	//如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，
	//如果是按照插入的先后顺序排序，则不做任何事情。
    if (lm.accessOrder) {
        lm.modCount++;
        remove();//移除当前访问的Entry
        addBefore(lm.header);//将当前访问的Entry插入到链表的尾部
    }
}

 // 继承了HashMap.Entry  
private static class Entry<K, V> extends HashMap.Entry<K, V> {  
 
    void recordRemoval(HashMap<K, V> m) {  
        remove();  
    }  
      
    //让当前Entry从header链表中消失  
    private void remove() {  
        before.after = after;  
        after.before = before;  
    }  
}  
    

	//迭代器
    private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
            return nextEntry != header;
        }

        public void remove() {
            if (lastReturned == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
        }
        //从head的下一个节点开始迭代
        Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (nextEntry == header)
                throw new NoSuchElementException();

            Entry<K,V> e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
        }
    }
    //key迭代器
    //看出这三个类都很简单，只有一个next()方法，next()方法也只是去调用LinkedHashIterator类中相应的方法
    private class KeyIterator extends LinkedHashIterator<K> {
        public K next() { return nextEntry().getKey(); }
    }
    //value迭代器
    private class ValueIterator extends LinkedHashIterator<V> {
        public V next() { return nextEntry().value; }
    }
    //Entry迭代器
    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() { return nextEntry(); }
    }

/*LRU是Least Recently Used 近期最少使用算法。
 *通过HashLiekedMap实现LRU的算法的关键是，如果map里面的元素个数大于了缓存最大容量，则删除链表头元素
 */

/*public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)
 *LRU参数参数：
 *initialCapacity - 初始容量。
 *loadFactor - 加载因子（需要是按该因子扩充容量）。
 *accessOrder - 排序模式( true) - 对于访问顺序（get一个元素后，这个元素被加到最后，使用了LRU  最近最少被使用的调度算法），对于插入顺序，则为 false,可以不断加入元素。
 */

 /*相关思路介绍：
  * 当有一个新的元素加入到链表里面时，程序会调用LinkedHahMap类中Entry的addEntry方法，
  *而该方法又会 会调用removeEldestEntry方法，这里就是实现LRU元素过期机制的地方，
  * 默认的情况下removeEldestEntry方法只返回false，表示可以一直表链表里面增加元素，在这个里  *修改一下就好了。 
  *
  */
 
/*
测试数据：
11
7 0 7 1 0 1 2 1 2 6
*/

import java.util.*;
public class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{     
    private int capacity;                     //初始内存容量
    
    LRULinkedHashMap(int capacity){          //构造方法，传入一个参数
        super(16,0.75f,true);               //调用LinkedHashMap，传入参数    
        this.capacity=capacity;             //传递指定的最大内存容量
    }
    @Override
    public boolean removeEldestEntry(Map.Entry<K, V> eldest){     
        //，每加入一个元素，就判断是size是否超过了已定的容量
        System.out.println("此时的size大小="+size());
        if((size()>capacity))
        {
            System.out.println("超出已定的内存容量，把链表顶端元素移除："+eldest.getValue());
        }
        return size()>capacity;        
    }
    
    public static void main(String[] args) throws Exception{//方便实例，直接将异常抛出
        Scanner cin = new Scanner(System.in);
        
        System.out.println("请输入总共内存页面数： ");
        int n = cin.nextInt();
        Map<Integer,Integer> map=new LRULinkedHashMap<Integer, Integer>(n);
        
        System.out.println("请输入按顺序输入要访问内存的总共页面数： ");
        int y = cin.nextInt();
        
        System.out.println("请输入按顺序输入访问内存的页面序列： ");
        for(int i=1;i<=y;i++)
        {
            int x = cin.nextInt();
            map.put(x,  x);  
        }
        System.out.println("此时内存中包含的页面数是有:");
        //遍历此时内存中的页面并输出
        for(java.util.Map.Entry<Integer, Integer> entry: map.entrySet()){
            System.out.println(entry.getValue());
        }
    }
}

NamevirtualHost *:80

<VirtualHost *:80>
	ServerName a.com
	DocumentRoot /var/www/site
</VirtualHost>

<VirtualHost *:80>
	ServerName bbs.a.com
	DocumentRoot /var/www/bbs
</VirtualHost>

    public class Permutate {
        public static int total = 0;
        public static void swap(String[] str, int i, int j)
        {
	        String temp = new String();
	        temp = str[i];
	        str[i] = str[j];
	        str[j] = temp;
        }
        public static void arrange (String[] str, int st, int len)
        {
                if (st == len - 1)
                {
                        for (int i = 0; i < len; i ++)
                        {
                                System.out.print(str[i]+ "  ");
                        }
                        System.out.println();
                        total++;
                }
                else
                {
                        for (int i = st; i < len; i ++)
                        {
                                swap(str, st, i);
                                arrange(str, st + 1, len);
                                swap(str, st, i);
                        }
                }
		
        }
	/**
	 * @param args
	 */
        public static void main(String[] args) {
                String str[] = {"a", "b", "c", "d", "e"};
                arrange(str, 0, str.length);
                System.out.println(total);
        }
    }