Hibernate提供了两种锁机制，悲观锁和乐观锁。

1.悲观锁

其中悲观锁的实现依赖于数据库的锁机制，如果数据库底层没有实现相应的数据排他性，那么就无法实现悲观锁。

加锁模式有：

LockMode.None 不加锁

LockMode.Write    在insert和update的时候会自动获取  / /还是不明白的因为没有用过

LockMode.Read    在读取数据的时候自动获取             /还是不明白的因为没有用过

以上三种都是在Hibernate内部进行使用的。

LockMode.UPGRADE是利用数据库的select..... for update语句进行加锁的。

LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁

以下是编程实现的语句：

String hql = 'from Tuser as user where user.name='maojiangege'';

Query query = session.createQuery(hql);

query.setLockMode(“user',LockMode.UPGRADE);

List list = query.list();

获取数据 query.setLockMode 对查询语句中特定别名所对

文章转自：http://blog.csdn.net/vastskyjoe/archive/2009/01/07/3729149.aspx

如果 使用HIbernate循环查询某个表的话。他会使用缓存技术，来提高数据库性能。

其思路是：第一次执行某个sql语句，记录下他的参数。第二次执行某个sql语句时候首先拿他的参数表和默认记录的参数表相比较，如果参数表一致，那么hibernate不会重新查询数据库，而是从缓存中读取他的值。因此连续执行某个查询语句的话，如果此时数据库中关于这个表的字段有更新，将不会显示。

附：当两个sql语句完全一样时候，他们的参数表一致。

解决思路：1.使每次执行的查询语句都不一样，但是查询出的结果都一样。

   类比：当我们在页面上输入于上个页面一致的地址时候 ，页面默认不会重新向服务器提交请求，而是从缓存钟读取页面。

如果要求他强制: 向服务器提交请求，可以，设置页面的属性。最简单的是地址后面加一个无关的随即书

http://www.baidu.com?id=1;

2.因为缓存的生

文章转自：http://luckyapple.javaeye.com/blog/457298

 suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。但suspend()方法很容易引起死锁问题，已经不推荐使用了。

文章转自：http://luckyapple.javaeye.com/blog/457298

 suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。但suspend()方法很容易引起死锁问题，已经不推荐使用了。

 
import java.util.HashMap;

public class TestDom4jReadExmple {
 public static void main(String[] args) {
     try{
       //获取解析完后的解析信息
       HashMap<String,String> hashMap;
       Dom4jReadExmple drb=new Dom4jReadExmple();
       //遍历整个XML文件
       hashMap = new HashMap<String,String>();
       drb.iterateWholeXML('C:\\studentInfo.xml', hashMap);
       System.out.println('姓名\t年龄\t学院\t学院领导\t电话\t\t备注');
       for(int i=0;i<hashMap.size();i+=6){
         int j=i/

class ShellSort {
 private int[] intArray; // 待排序的数组

 private int nItems; // 数组内元素个数

 private int maxItems; // 数组大小

 private int[] intervalSequence; // 增量数组序列

 // 构造函数

 public ShellSort(int maxItems, int[] intervalSequence) {
  this.intArray = new int[maxItems];
  this.maxItems = maxItems;
  this.nItems = 0;// 还没有元素

  this.intervalSequence = intervalSequence;
 }

 
 public void shellSortMethod() {
  int h = 0;// 为增量

  for (int iIntervalLength = 0; iIntervalLength < intervalSequence.length; iIntervalLength++)// 最外层循环，由增量序列元素个数决定

  {
   h = intervalSequence[iIntervalLength];// h为index增量

   int sizeInterArray;// 每次内部插入排序的元素个数

   if (0 ==

public class MergeSort {

 public int[] sort(int[] data) {
  int[] temp = new int[data.length];
  mergeSort(data, temp, 0, data.length - 1);
  return data;
 }

 private void mergeSort(int[] data, int[] temp, int l, int r) {
  int mid = (l + r) / 2;
  System.out.println(l + ', ' + mid + ', ' + r);
  if (l == r)
   return;

  mergeSort(data, temp, l, mid);
  mergeSort(data, temp, mid + 1, r);
  for (int i = l; i <= r; i++) {
   System.out.println('i=' + i);
   temp[i] = data[i];
  }
  int i1 = l;
  int i2 = mid + 1;
  for (int cur = l; cur <= r; cur++) {
   if (i1 == mid + 1)
    data[cur] = temp[i2++];
   else if

 

public class HeapOp {
    private PriorityQueue queue = new PriorityQueue();
   
    public HeapOp() {
       
    }
    public void insert(int a) {
        queue.add(a);
    }
   
    public int retrive() {
        int a =  queue.getMin();
        queue.removeMin();
        return a;
    }
   
    public boolean isQueueEmpty() {
        return queue.isEmpty();
    }
    class PriorityQueue {
 &nbs

Java  shixian kuaisupa
public class QuicklySort {   
      
       
    public static void QuickSort(int[] pData,int left,int right)   
    {    
      int i,j;   
      int middle,temp;   
      i = left;   
      j = right;   
      middle = pData[left];   
      while(true)   
      {   
          while((++i)<right-1 && pData[i]<middle);   
          while((