昨天上网找一个同步工具，windows同步到linux，额，ms不少，但是配置实在是麻烦，而且很多按照步骤做下来 都不能使用，(估计rp问题)，最郁闷的事莫过如此，经过一个下午的努力，额，原来真的行的，分享给大家。(估计很多人会觉得啰嗦)

一.介绍 (不想看直接可以跳过)

Rsync是一个远程数据同步工具，可通过LAN/WAN快速同步多台主机间的文件。Rsync本来是用以取代rcp的一个工具，它当前由 rsync.samba.org维护。Rsync使用所谓的“Rsync演算法”来使本地和远程两个主机之间的文件达到同步，这个算法只传送两个文件的不同部分，而不是每次都整份传送，因此速度相当快。运行Rsync server的机器也叫backup server，一个Rsync server可同时备份多个client的数据；也可以多个Rsync server备份一个client的数据。

　　Rsync可以搭配rsh或ssh甚至使用daemon模式。Rsync server会打开一个873的服务通道(port)，等待对方Rsync连接。连接时，Rsync server会检查口令是否相符，若通过口令查核，则可以开始进行文件传输。第一次连通完成时，会把整份文件传输一次，下一次就只传送二个文件之间不同的部份。

　　Rsync支持大多数的类Unix系统，无论是Linux、Solaris还是BSD上都经过了良好的测试。此外，它在windows平台下也有相应的版本，比较知名的有cwRsync和Sync2NAS。

　　Rsync的基本特点如下：

　　1.可以镜像保存整个目录树和文件系统；

　　2.可以很容易做到保持原来文件的权限、时间、软硬链接等；

　　3.无须特殊权限即可安装；

　　4.优化的流程，文件传输效率高；

　　5.可以使用rcp、ssh等方式来传输文件，当然也可以通过直接的socket连接；

6.支持匿名传输。

核心算法介绍：

假定在名为α和β的两台计算机之间同步相似的文件A与B，其中α对文件A拥有访问权，β对文件B拥有访问权。并且假定主机α与β之间的网络带宽很小。那么rsync算法将通过下面的五个步骤来完成：

　　1.β将文件B分割成一组不重叠的固定大小为S字节的数据块。最后一块可能会比S 小。

　　2.β对每一个分割好的数据块执行两种校验：一种是32位的滚动弱校验，另一种是128位的MD4强校验。

　　3.β将这些校验结果发给α。

　　4.α通过搜索文件A的所有大小为S的数据块(偏移量可以任选，不一定非要是S的倍数)，来寻找与文件B的某一块有着相同的弱校验码和强校验码的数据块。这项工作可以借助滚动校验的特性很快完成。

　　5.α发给β一串指令来生成文件A在β上的备份。这里的每一条指令要么是对文件B经拥有某一个数据块而不须重传的证明，要么是一个数据块，这个数据块肯定是没有与文件B的任何一个数据块匹配上的。

命令：

rsync的命令格式可以为以下六种：

　　rsync [OPTION]... SRC DEST

　　rsync [OPTION]... SRC [USER@]HOST:DEST

　　rsync [OPTION]... [USER@]HOST:SRC DEST

　　rsync [OPTION]... [USER@]HOST::SRC DEST

　　rsync [OPTION]... SRC [USER@]HOST::DEST

　　rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]

　　对应于以上六种命令格式，rsync有六种不同的工作模式：

　　1)拷贝本地文件。当SRC和DES路径信息都不包含有单个冒号":"分隔符时就启动这种工作模式。

　　2)使用一个远程shell程序(如rsh、ssh)来实现将本地机器的内容拷贝到远程机器。当DST路径地址包含单个冒号":"分隔符时启动该模式。

　　3)使用一个远程shell程序(如rsh、ssh)来实现将远程机器的内容拷贝到本地机器。当SRC地址路径包含单个冒号":"分隔符时启动该模式。

　　4)从远程rsync服务器中拷贝文件到本地机。当SRC路径信息包含"::"分隔符时启动该模式。

　　5)从本地机器拷贝文件到远程rsync服务器中。当DST路径信息包含"::"分隔符时启动该模式。

　　6)列远程机的文件列表。这类似于rsync传输，不过只要在命令中省略掉本地机信息即可。

二.安装

1.从原始网站下载：[url]http://rsync.samba.org/ftp/rsync/[/url]  (http://rsync.samba.org/ftp/rsync/rsync-3.0.7.tar.gz目前是这个版本)

windows版本：
客户端：cwRsync_2.0.10_Installer http://blogimg.chinaunix.net/blog/upfile/070917224721.zip 
服务端：cwRsync_Server_2.0.10_Installer   http://blogimg.chinaunix.net/blog/upfile/070917224837.zip

对于client 和 server都是windows的，那么可以直接安装如上2个，然后可以通过建 windows的任务，实现定时处理，可以参考：
http://blog.csdn.net/daizhj/archive/2009/11/03/4765280.aspx

2.[root@localhost bin]#./configure
[root@localhost bin]#make
[root@localhost bin]#make install

这里可能会有权限问题，切换到root用户


Rsync配置
/etc/rsyncd.conf  (默认是没有的，可以手工创建)
#全局选项
strict modes =yes                        #是否检查口令文件的权限
port = 873                               #默认端口873
log file = /var/log/rsyncd.log           #日志记录文件    原文中有的，我没有使用，日志文件
pid file = /usr/local/rsync/rsyncd.pid   #运行进程的ID写到哪里   原文中有的，我没有使用，日志文件

#模块选项
[test]                                   # 这里是认证的模块名，在client端需要指定
max connections = 5                      #客户端最大连接数,默认0(没限制)
         uid = root                      #指定该模块传输文件时守护进程应该具有的uid
         gid = root                      #指定该模块传输文件时守护进程应该具有的gid
          path = /home/admin/testrsync   # 需要做备份的目录
          ignore errors                  # 可以忽略一些无关的IO错误
          read only = no                 #no客户端可上传文件,yes只读
          write only = no                #no客户端可下载文件,yes不能下载
          hosts allow = *                #充许任何主机连接
          hosts deny = 10.5.3.77         #禁止指定的主机连接
          auth users = root              # 认证的用户名，如果没有这行，则表明是匿名
          secrets file = /home/admin/security/rsync.pass    # 指定认证口令文件位置

   
生成rsync密码文件
在server端生成一个密码文件/home/admin/security/rsync.pass
      
       vi rsync.pass
 
        root:hell05a
  

注意：密码文件的权限，是由rsyncd.conf里的参数
strict modes =yes/no 来决定
Rsync 的启动
 rsycn 的启动方式有多种，我们在这里介绍以下几种：
●. 守护进程方式：(我现在只使用这个)
/usr/local/bin/rsync --daemon

验证启动是否成功
 ps -aux |grep rsync
 root       59120  0.0  0.2  1460   972  ??  Ss    5:20PM   0:00.00  /usr/local/rsync/bin/rsync –daemon

netstat -an |grep 873
tcp4       0      0  *.873                  *.*                    LISTEN

结束进程：kill -9 pid的值
kill -15 进程名

如果是linux之间同步，只需要安装rsync，如果是需要linux与windows之间同步，安装 cwrsync

三.客户端访问：（客户端也需要安装 rsync,如果是windows，安装cwrsync）

实例演示使用:

下载文件：
./rsync  -vzrtopg --progress --delete  root@xxx.xxx.xxx.xxx::backup  /home/admin/getfile

上传文件：
/usr/bin/rsync -vzrtopg --progress /home/admin/getfile  root@xxx.xxx.xxx.xxx::backup


Rsync 同步参数说明
-vzrtopg里的v是verbose，z是压缩，r是recursive，topg都是保持文件原有属性如属主、时间的参数。
--progress是指显示出详细的进度情况
--delete是指如果服务器端删除了这一文件,那么客户端也相应把文件删除
root@xxx.xxx.xxx.xxx中的root是指定密码文件中的用户名,xxx为ip地址
backup 是指在rsyncd.conf里定义的模块名
/home/admin/getfile 是指本地要备份目录


可能出现的问题：
@ERROR: auth failed on module backup
rsync error: error starting client-server protocol (code 5) at main.c(1506) [Receiver=3.0.7]
那估计是密码文件没有设置权限哦：  chmod 600 /home/admin/security/rsync.pass
应该差不多就可以了。



(2)打开rsync服务
#chkconfig xinetd on
#chkconfig rsync on

(4)启动基于xinetd进程的rsync服务t
#/etc/init.d/xinetd start


3、配置windows的rsync客户端
(1)安装client端的rsync包
(2)打开cmd,执行同步计划：
cd C:\Program Files\cwRsync\bin

下载同步(把服务器上的东东下载当前目录)
rsync -vzrtopg --progress --delete root@xxx.xxx.xxx.xxx::backup  ./ff
(此时须输入root用户的密码，就可进行同步了。)

上传同步(把本地东东上传到服务器)
rsync -vzrtopg --progress ./get/  root@xxx.xxx.xxx.xxx::backup



参数说明
-v, --verbose 详细模式输出
-q, --quiet 精简输出模式
-c, --checksum 打开校验开关，强制对文件传输进行校验
-a, --archive 归档模式，表示以递归方式传输文件，并保持所有文件属性，等于-rlptgoD
-r, --recursive 对子目录以递归模式处理
-R, --relative 使用相对路径信息
-b, --backup 创建备份，也就是对于目的已经存在有同样的文件名时，将老的文件重新命名为~filename。可以使用--suffix选项来指定不同的备份文件前缀。
--backup-dir 将备份文件(如~filename)存放在在目录下。
-suffix=SUFFIX 定义备份文件前缀
-u, --update 仅仅进行更新，也就是跳过所有已经存在于DST，并且文件时间晚于要备份的文件。(不覆盖更新的文件)
-l, --links 保留软链结
-L, --copy-links 想对待常规文件一样处理软链结
--copy-unsafe-links 仅仅拷贝指向SRC路径目录树以外的链结
--safe-links 忽略指向SRC路径目录树以外的链结
-H, --hard-links 保留硬链结     -p, --perms 保持文件权限
-o, --owner 保持文件属主信息     -g, --group 保持文件属组信息
-D, --devices 保持设备文件信息    -t, --times 保持文件时间信息
-S, --sparse 对稀疏文件进行特殊处理以节省DST的空间
-n, --dry-run现实哪些文件将被传输
-W, --whole-file 拷贝文件，不进行增量检测
-x, --one-file-system 不要跨越文件系统边界
-B, --block-size=SIZE 检验算法使用的块尺寸，默认是700字节
-e, --rsh=COMMAND 指定使用rsh、ssh方式进行数据同步
--rsync-path=PATH 指定远程服务器上的rsync命令所在路径信息
-C, --cvs-exclude 使用和CVS一样的方法自动忽略文件，用来排除那些不希望传输的文件
--existing 仅仅更新那些已经存在于DST的文件，而不备份那些新创建的文件
--delete 删除那些DST中SRC没有的文件
--delete-excluded 同样删除接收端那些被该选项指定排除的文件
--delete-after 传输结束以后再删除
--ignore-errors 及时出现IO错误也进行删除
--max-delete=NUM 最多删除NUM个文件
--partial 保留那些因故没有完全传输的文件，以是加快随后的再次传输
--force 强制删除目录，即使不为空
--numeric-ids 不将数字的用户和组ID匹配为用户名和组名
--timeout=TIME IP超时时间，单位为秒
-I, --ignore-times 不跳过那些有同样的时间和长度的文件
--size-only 当决定是否要备份文件时，仅仅察看文件大小而不考虑文件时间
--modify-window=NUM 决定文件是否时间相同时使用的时间戳窗口，默认为0
-T --temp-dir=DIR 在DIR中创建临时文件
--compare-dest=DIR 同样比较DIR中的文件来决定是否需要备份
-P 等同于 --partial
--progress 显示备份过程
-z, --compress 对备份的文件在传输时进行压缩处理
--exclude=PATTERN 指定排除不需要传输的文件模式
--include=PATTERN 指定不排除而需要传输的文件模式
--exclude-from=FILE 排除FILE中指定模式的文件
--include-from=FILE 不排除FILE指定模式匹配的文件
--version 打印版本信息
--address 绑定到特定的地址
--config=FILE 指定其他的配置文件，不使用默认的rsyncd.conf文件
--port=PORT 指定其他的rsync服务端口
--blocking-io 对远程shell使用阻塞IO
-stats 给出某些文件的传输状态
--progress 在传输时现实传输过程
--log-format=formAT 指定日志文件格式
--password-file=FILE 从FILE中得到密码
--bwlimit=KBPS 限制I/O带宽，KBytes per second      -h, --help 显示帮助信息

Collection接口 由  Set接口 和 List接口 继承。

      Set 被 Vector . ArrayList LinkedList 实现。

      List 被 HashSet  TreeSet 实现。

Map接口 由 HashTable HashMap  TreeMap 实现。


下面看下每个实现类的特征；；；--》(转的。)

1. List  (有重复、有序)

 Vector基于Array的List，性能也就不可能超越Array，并且Vector是“sychronized”的，这个也是Vector和ArrayList的唯一的区别。

ArrayList：同Vector一样是一个基于Array的，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快。

数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了所以它适合于进行频繁进行插入和删除操作。这就是LinkedList的优势。Iterator只能对容器进行向前遍历，而 ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。
用在FIFO，用addList()加入元素 removeFirst()删除元素
用在FILO,用addFirst()/removeLast()
ListIterator 提供双向遍历next() previous()，可删除、替换、增加元素

List总结： 1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]； 2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]； 3. 所有的List中可以有null元素，例如[ tom,null,1 ]； 4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。


2. Set

HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项，这也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。HashSet能快速定位一个元素，但是放到HashSet中的对象需要实现hashCode()方法0。

TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要重复定义相同的排序算法，只要实现Comparator接口即可。TreeSet是SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。
      Set总结： 1. Set实现的基础是Map（HashMap）； 2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象； Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别? Set里的元素是不能重复的，即不能包含两个元素e1、e2（e1.equals（e2））。那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。==方法决定引用值(句柄)是否指向同一对象。


3. Map

 Map是一种把键对象和值对象进行关联的容器，Map有两种比较常用的实现： HashTable、HashMap和TreeMap。

 HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它有一些扩展的方法，比如firstKey(),lastKey()等。
只有HashMap可以让你将空值作为一个表的条目的key或value

HashMap和Hashtable的区别。 HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口。主要区别在于HashMap允许空（null）键（key）或值（value）,非同步，由于非线程安全，效率上可能高于Hashtable。 Hashtable不允许空（null）键（key）或值（value），Hashtable的方法是Synchronize的，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

HashMap:
    散列表的通用映射表，无序，可在初始化时设定其大小，自动增长。
    只有HashMap可以让你将空值作为一个表的条目的key或value

LinkedHashMap:
    扩展HashMap，对返回集合迭代时，维护插入顺序

WeakHashMap:
    基于弱引用散列表的映射表，如果不保持映射表外的关键字的引用，则内存回收程序会回收它

TreeMap:
    基于平衡树的映射表 

  内存泄漏几种常见的方式：
  1. 无意识的对象保持。 就是接下来的例子。

  2. 使用缓存。(很长一段时间仍然留在缓存中)
       

    一旦你把对象引用放到缓存中，它就很容易被遗忘掉，从而使得它不再有用之后很长一段时间内仍然留在缓存中。对于这个问题，有几种可能的解决方案。如果你正好要实现这样的缓存：只要在缓存之外存在对某个项的键的引用，该项就有意义，那么就可以用WeakHashMap代表缓存；当缓存中的项过期之后，它们就会自动被删除。记住只有当所要的缓存项的生命周期是由该键的外部引用而不是由值决定时，WeakHashMap才有用处。

更为常见的情形则是，"缓存项的生命周期是否有意义"并不是很容易确定，随着时间的推移，其中的项会变得越来越没有价值。在这种情况下，缓存应该时不时地清除掉没用的项。这项清除工作可以由一个后台线程（可能是Timer或者ScheduledThreadPoolExecutor）来完成，或者也可以在给缓存添加新条目的时候顺便进行清理。LinkedHashMap类利用它的removeEldestEntry方法可以很容易地实现后一种方案。对于更加复杂的缓存，必须直接使用java.lang.ref。

   3. 监听器和其他回调

    如果你在实现的是客户端注册回调却没有显式地取消注册的API，除非你采取某些动作，否则它们就会积聚。确保回调立即被当作垃圾回收的最佳方法是只保存它们的弱引用（weak reference），例如，只将它们保存成WeakHashMap中的键。



对于 1.无意识的对象保持，代码：

修改方式：
    把上面的pop方法修改成如下：
   

清空过期引用的另一个好处是，如果它们以后又被错误地解除引用，程序就会立即抛出NullPointerException异常，而不是悄悄地错误运行下去。尽快地检测出程序中的错误总是有益的。

  第二条  遇到多个构造器参数时要考虑用构造器

这里考虑的是参数多的情况，如果参数个数比较少，那直接采用一般的构造方法就可以了。

   书中介绍了写构造方法的时候几种方式：

    1. 重叠构造方法模式:
       缺点：有许多参数的时候，客户端代码会很难写，而且较难以阅读。

     2. javaBeans模式：
       缺点：  
            在构造过程中JavaBean可能处于不一致的状态，类本身无法判断是否有效性。
            类做成不可变的可能。

     3. builder模式：
       优点：
            在build方法生成对象的时候，可以做检查，判断是否符合要求
            参数灵活
       缺点：
            创建对象必须先创建构造器，如果对性能要求非常高的应用少用为妙



具体实现代码：
1.重叠构造方法模式：



2. javaBeans模式 代码：


 3. builder模式
 这个调用的时候： 
NutritionFacts cocaCola = new NutritionFacts.Builder(11,22).calories(1).fat(2).calories(3).build();

        
        在Java中设置变量值的操作，除了long和double类型的变量外都是原子操作，也就是说，对于变量值的简单读写操作没有必要进行同步。

这在JVM 1.2之前，Java的内存模型实现总是从主存读取变量，是不需要进行特别的注意的。而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

文章出处：DIY部落(http://www.diybl.com/course/3_program/java/javaxl/20090302/156333.html)

同时查看下IBM中的详细解释：

         
       今天在熟悉我们的项目的时候，sql中看到FORCE INDEX，额，都不知道什么东东，有什么特别用处吗？ 查了下资料，原来是这样啊，发现一般不搞复杂sql，而且复杂sql DBA也不允许，但优化的sql 还是有必要了解下。（一般来说也不太会使用，总被DBA pk了）

        下面部分转：
        对于经常使用oracle的朋友可能知道，oracle的hint功能种类很多，对于优化sql语句提供了很多方法。同样，在mysql里，也有类似的hint功能。下面介绍一些常用的。

      1。强制索引 FORCE INDEX

SELECT * FROM TABLE1 FORCE INDEX (FIELD1) …

以上的SQL语句只使用建立在FIELD1上的索引，而不使用其它字段上的索引。

       2。忽略索引 IGNORE INDEX

SELECT * FROM TABLE1 IGNORE INDEX (FIELD1, FIELD2) …

在上面的SQL语句中，TABLE1表中FIELD1和FIELD2上的索引不被使用。

       3。关闭查询缓冲 SQL_NO_CACHE

SELECT SQL_NO_CACHE field1, field2 FROM TABLE1;

有一些SQL语句需要实时地查询数据，或者并不经常使用（可能一天就执行一两次）,这样就需要把缓冲关了,不管这条SQL语句是否被执行过，服务器都不会在缓冲区中查找，每次都会执行它。

      4。强制查询缓冲 SQL_CACHE

SELECT SQL_CALHE * FROM TABLE1;

如果在my.ini中的query_cache_type设成2，这样只有在使用了SQL_CACHE后，才使用查询缓冲。

     5。优先操作 HIGH_PRIORITY

HIGH_PRIORITY可以使用在select和insert操作中，让MYSQL知道，这个操作优先进行。

SELECT HIGH_PRIORITY * FROM TABLE1;

     6。滞后操作 LOW_PRIORITY

LOW_PRIORITY可以使用在insert和update操作中，让mysql知道，这个操作滞后。

update LOW_PRIORITY table1 set field1= where field1= …

    7。延时插入 INSERT DELAYED

INSERT DELAYED INTO table1 set field1= …

INSERT DELAYED INTO，是客户端提交数据给MySQL，MySQL返回OK状态给客户端。而这是并不是已经将数据插入表，而是存储在内存里面等待排队。当mysql有空余时，再插入。另一个重要的好处是，来自许多客户端的插入被集中在一起，并被编写入一个块。这比执行许多独立的插入要快很多。坏处是，不能返回自动递增的ID，以及系统崩溃时，MySQL还没有来得及插入数据的话，这些数据将会丢失。

     8 。强制连接顺序 STRAIGHT_JOIN

SELECT TABLE1.FIELD1, TABLE2.FIELD2 FROM TABLE1 STRAIGHT_JOIN TABLE2 WHERE …

由上面的SQL语句可知，通过STRAIGHT_JOIN强迫MySQL按TABLE1、TABLE2的顺序连接表。如果你认为按自己的顺序比MySQL推荐的顺序进行连接的效率高的话，就可以通过STRAIGHT_JOIN来确定连接顺序。

    9。强制使用临时表 SQL_BUFFER_RESULT

SELECT SQL_BUFFER_RESULT * FROM TABLE1 WHERE …

当我们查询的结果集中的数据比较多时，可以通过SQL_BUFFER_RESULT.选项强制将结果集放到临时表中，这样就可以很快地释放MySQL的表锁（这样其它的SQL语句就可以对这些记录进行查询了），并且可以长时间地为客户端提供大记录集。

   10。分组使用临时表 SQL_BIG_RESULT和SQL_SMALL_RESULT

SELECT SQL_BUFFER_RESULT FIELD1, COUNT(*) FROM TABLE1 GROUP BY FIELD1;

一般用于分组或DISTINCT关键字，这个选项通知MySQL，如果有必要，就将查询结果放到临时表中，甚至在临时表中进行排序。SQL_SMALL_RESULT比起SQL_BIG_RESULT差不多，很少使用。

    其实这篇文章很早看到的，但仔细想想其实没多大意思，有一次维护代码的时候，发现一些看似有意思的写法，就在本博记录下，容易遗忘。
小技巧感觉上很有意思，但并不是很实用，容易理解的配合，方便维护的配置，才是最好的代码。搞点小技巧，不方便维护。

    在BeanFactory的配置中，<bean>是我们最常见的配置项，它有两个最常见的属性，即id和name，最近研究了一下，发现这两个属性还挺好玩的，特整理出来和大家一起分享。

1.id属性命名必须满足XML的命名规范，因为id其实是XML中就做了限定的。总结起来就相当于一个Java变量的命名：不能以数字，符号打头，不能有空格，如123，?ad,"ab "等都是不规范的，Spring在初始化时就会报错，
    org.xml.sax.SAXParseException: Attribute value "?ab" of type ID must be a name.

2.name属性则没有这些限定，你可以使用几乎任何的名称，如?ab,123等，但不能带空格，如"a b"," abc"，，这时，虽然初始化时不会报错，但在getBean()则会报出诸如以下的错误：
   org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'a b' is defined

3.配置文件中不允许出现两个id相同的<bean>，否则在初始化时即会报错，如：
  org.xml.sax.SAXParseException: Attribute value "aa" of type ID must be unique within the document.

4.但配置文件中允许出现两个name相同的<bean>，在用getBean()返回实例时，后面一个Bean被返回,应该是前面那个<bean>被后面同名的 <bean>覆盖了。有鉴于此，为了避免不经意的同名覆盖的现象，尽量用id属性而不要用name属性。

5.name属性可以用,隔开指定多个名字，如<bean name="b1,b2,b3">,相当于多个别名，这时通过getBean("a1") getBean("a2") getBean("a3")返回的都是同一个实例（假设是singleton的情况）

6.如果id和name都没有指定，则用类全名作为name，如<bean class="com.stamen.BeanLifeCycleImpl">,则你可以通过
getBean("com.biao.GroupThreadImpl")返回该实例。

7.如果存在多个id和name都没有指定，且实例类都一样的<bean>，如:

 <bean class="com.biao.GroupThreadImpl"/>



<bean class="com.biao.GroupThreadImpl"/>



<bean class="com.biao.GroupThreadImpl"/>



则第一个bean通过getBean("com.biao.GroupThreadImpl")获得， 



第二个bean通过getBean("com.biao.GroupThreadImpl#1")获得， 



第三个bean通过getBean("com.biao.GroupThreadImpl#2")获得，以此类推。 

倒计时：

结束考试 

   Cookie是在Web上用于存储客户系统信息的对象。所有的信息都以每行一个Cookie的形式存放在客户端的一个名为cookies.txt的文件里。Cookie在HTTP头标(客户和服务器用来标识自身的分组)中在客户机与服务器之间传输。

   Cookie由某个WWW网页在某客户机上进行设置。比如,某个WWW网页已在一个用户的计算机上设置了一个Cookie,其中存储的信息是该用户的身份号(随机赋予该用户的唯一标识),当该用户的浏览器连接该WWW站点时,站点要求浏览器将Cookie送回,他的身份号就通过Cookie 传递给该网页所在的WWW服务器。服务器上的一个CGI程序查找一个服务器端的文件以确定关于他的预设内容。

   当某个服务器在客户的计算机上设置Cookie后,请注意如果要让Cookie信息确实写入文件,必须关闭浏览器。在浏览器未关闭之前,任何新的或变化的Cookie都存放在内存中。

二、Cookie的特性
   每个Cookie包含有6个元素,常用的有:name、value、expires、domain和secure。这些元素存放了这个Cookie的作用范围及实际的数据。
   1.name  这是每一个Cookie必须有的元素,它是该Cookie的名字。name元素是一个不含分号、逗号和空格的字符串。其命名方式与变量命名相同。
   2.value  value也是每个Cookie必须有的元素,它是该Cookie的值。value元素是实际存放于Cookie中的信息。它是由任何字符构成的字符串。
   3.expires  expires是一个Cookie的过期时间。没有设置expires元素的Cookie在用户断开连接后过期,但在用户关闭浏览器之前Cookie依然存在。
   Cookie有一个过期时间并等于它会从Cookie.txt文件中被删除。在它的位置被用来存放另一个Cookie前,它依然存在着。过期的Cookie只是不被送往要求使用它的服务器。
   expire是一个串,它的形式如下:
   Wdy, DD-Mon-YY HH:MM:SS GMT
   expires元素是可选的。
   4.domain  domain是设置某个Cookie的Web网页所在的计算机的域名。这样,由一个站点创建的Cookie不会影响到另一个站点上的程序。对于较高层的域名如.com, .edu,或.mil,域名中至少有两个分隔符(.)。而对于较低层的域名如.cn, .uk或.ca,域名中至少有3个分隔符。demain元素自动地被设为网页所在站点的基本域名。比如,你的网页位于http://www.abc.com/～user,则该网页创建的Cookie缺省地对域abc.com有效。如果你希望你的Cookie 只应用于服务器www3.abc.com,那么你必须在设置Cookie的时候指定。
   只有拥有域名的站点才能为那个域名设置Cookie
   5.path  一个Cookie可以被指定为只针对一个站点的某一层次。如果一个Web站点要区分已注册的和未注册的客户,就可以为已经注册的客户设置Cookie,当注册过的客户访问该站点时,他就可以访问到只对注册客户有效的页面。path是可选项,如果没有指定path,将被缺省地设置为设置Cookie的页面的路径。
   6.secure标志  secure是一个布尔值(真或假)。它的缺省值为假。如果它被设为真值, 这个Cookie只被浏览器认为是安全的服务器所记住。

三、关于Cookie的一些限制

   一个站点能为一个单独的客户最多设置20个Cookie。如果一个站点有两个服务器(如www.abc.com和www3.abc.com)但没有指定域名,Cookie的域名缺省地是abc.com。如果指定了确切的服务器地址,则每个站点可以设置20个Cookie--而不是总共20个。不仅每个服务器能设置的Cookie数目是有限的,而且每个客户机最多只能存储300个Cookie。如果一个客户机已有300个Cookie,并且一个站点在它上面又设置了一个新Cookie,那么,先前存在的某一个Cookie将被删除。
   每个Cookie也有自身的限制。Cookie不得超过4KB(4096bytes),其中包括名字和其他信息。
四、javascript和Cookie

   现在大家已经了解有关Cookie的一些基本概念了,让我们更进一步讨论Cookie。可以用javascript来很方便地编写函数用来创建、读取和删除Cookie。下面,我们就介绍这些函数

   1.创建Cookie

   我们要进行的第一件事就是要创建一个Cookie。下面给出的SctCookie()函数将完成这一功能。
   function SetCookit (name, value) {
     var argv=SetCookie.arguments;
     var argc=SetCookie.arguments.length;
     var expires=(argc>2)?argv[2]: null;
     var path=(argc>3)? argv[3]: null;
     var domain=(argc>4)? argv[4]: null;
     var secure=(argc>5)? argv[5]: false;
     documents.cookie=name+"="+escape
       (value)+
     ((expires==null)?"":(";expires="
       +expires.toGMTString()))+
     ((path==null)?"":(";path="+path))+
     ((domain==null)?"":(";domain="+
       domain))+
     ((secure==true)?";secure":"");
   }
   SetCookie()只要求传递被设置的Cookie的名字和值,但如果必要的话你可以设置其他4 个参数而不必改变这个函数。可选的参数必须用正确的次序使用。如果不想设置某个参数, 必须设置一个空串。比如,如果我们创建的一个Cookie需要指定secure域,但不想设置expires, patb或domain,就可以像这样调用SetCokie():  SetCookie("MyNewCookie","Myvalue" ,"",","tyue);
   2.读取Cookie

   下面给出的函数GetCookie()用来读取一个Cookie。当一个Cookie的请求被客户机收到时,该客户机查找它的cookies.txt文件以进行匹配。这个函数首先匹配这个Cookie的名字。如果有多个同名的Cookie,它再匹配路径。函数完成匹配后返回这个Cookie的值。如果客户机中没有这个Cookie,或者路径不匹配,该函数返回一个NULL。
   function GetCookie(name) {
     var arg=name+ "=";
     var alen=arg.length;
     var clen=documents.cookie.length;
     var i=0;
     while (i<clen) {
       var j=i+alen;
       if(documents.cookie.substring(i,j)
       ==arg)
       return getCookieVal(j);
       i=documents.cookie.indexOf("",i)+1;
       if(i==0)break;
     }
     return null;
   }
   函数中使用了getCookieVal()函数,它是GetCookie()函数的补充。getCookieVal()将C ookies.txt文件分解为片断,并从一批Cookie中读出正确的Cookie。该函数的实现如下:
   function getCookieVal(offset) {
     var endstr=documents.cookie.indexOf
       (";",offset);
     if(endstr==-1) //没有指定其他元素
       endstr=documents.cookie.length;
     return unescape(documents.cookie.substring
       (offset,endstr));
   }

   3.删除Cookie

   删除一个Cookie很简单,只需将它的过期时间设为NULL。当用户断开连接后,这个Cooki e就过期了(没有过期时间的Cookie将在浏览器关闭时被删除)。下面的函数DeleteCookie() 说明了如何删除一个
Cookie:
   function DeleteCookie(name) {
     var exp=new Date();
     exp.setTime(exp.getTime()-1);
     //将exp设为已过期的时间
     var cval=GetCookie(name);
     documents.cookie=name+"="+cval+";
     expires="+exp.toGMTString();
   }

        网上的解释原因：
Iterator 是工作在一个独立的线程中，并且拥有一个 互斥 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。  
           
          廖雪峰 大师  Java源码分析：深入探讨Iterator模式  http://gceclub.sun.com.cn/yuanchuang/week-14/iterator.html


在工作碰到这个问题所有看看：
List list = ...;
for(Iterator iter = list.iterator(); iter.hasNext();) {
    Object obj = iter.next();
    ...
    if(***) {
        list.remove(obj);  //list.add(obj)  其实也是一样的。
    }
}
在执行了remove方法之后，再去执行循环，iter.next()的时候，报java.util.ConcurrentModificationException(当然，如果remove的是最后一条，就不会再去执行next()操作了)，

下面来看一下源码
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

public interface Collection<E> extends Iterable<E> {
    ...
    Iterator<E> iterator();
    boolean add(E o);
    boolean remove(Object o);
    ...
}


public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { 
//AbstractCollection和List都继承了Collection
    protected transient int modCount = 0;
    private class Itr implements Iterator<E> {  //内部类Itr
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification();  //该方法中检测到改变，从而抛出异常
            try {
                E next = get(cursor);
                lastRet = cursor++;
                return next;
            } catch(IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);  //执行remove对象的操作
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;  //重新设置了expectedModCount的值，避免了ConcurrentModificationException的产生
            } catch(IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)  //当expectedModCount和modCount不相等时，就抛出ConcurrentModificationException
                throw new ConcurrentModificationException();
        }
    }   
}

remove(Object o)在ArrayList中实现如下：
public boolean remove(Object o) {
    if (o == null) {
            for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
            fastRemove(index);
            return true;
        }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++;  //只增加了modCount
    ....
}

所以，产生ConcurrentModificationException的原因就是：
执行remove(Object o)方法之后，modCount和expectedModCount不相等了。然后当代码执行到next()方法时，判断了checkForComodification()，发现两个数值不等，就抛出了该Exception。
要避免这个Exception，就应该使用remove()方法，但是没有add()方法了，只能另建一个list来处理这个问题了。