1 // switch to manual commit if necessary. this is very expensive in some jdbc drivers,
 2 // so we don't want to do it unnecessarily (for example if we've explicitly
 3 // configured the connection pool to set it already).
 4 if (con.getautocommit()) {
 5     txobject.setmustrestoreautocommit(true);
 6     if (logger.isdebugenabled()) {
 7         logger.debug("switching jdbc connection [" + con + "] to manual commit");
 8     }
 9     con.setautocommit(false);
10 }

1 <!-- transaction support-->
2 <!-- PlatformTransactionMnager -->
3 <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
4     <property name="dataSource" ref="dataSource" />
5 </bean>
6 <!-- enable transaction annotation support -->
7 <tx:annotation-driven transaction-manager="txManager" />

 1 ...
 2     xmlns:tx="http://www.springframework.org/schema/tx"
 3     xmlns:aop="http://www.springframework.org/schema/aop"
 4     xsi:schemaLocation="
 5     ...
 6  
 7 http://www.springframework.org/schema/tx
 8  
 9  
10 http://www.springframework.org/schema/tx/spring-tx.xsd
11  
12     ...

1 public interface PlatformTransactionManager {
2  
3   TransactionStatus getTransaction(TransactionDefinition definition)
4     throws TransactionException;
5  
6   void commit(TransactionStatus status) throws TransactionException;
7  
8   void rollback(TransactionStatus status) throws TransactionException;
9 }

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("正在保存用户信息。。。");
    }
}

public class TransactionHandler implements UserDao {

    private UserDaoImpl target;

    public TransactionHandler(UserDaoImpl target){
        this.target = target;
    }

    @Override
    public void save() {
         System.out.println("开启事务控制。。。");
         target.save();
         System.out.println("关闭事务控制。。。");
     }

    public static void main(String[] args) {
        UserDaoImpl target = new UserDaoImpl();
        UserDao userDao = new TransactionHandler(target);
        userDao.save();
    }
}

@Value("Michael Jackson")
String name;

@Value("#{systemProperties['os.name']}")
String osName;

@Value("#{ T(java.lang.Math).random() * 100 }")
String randomNumber;

@Value("#{domeClass.name}")
String name;

@Value("classpath:com/hgs/hello/test.txt")
Resource file;

@Value("http://www.cznovel.com")
Resource url;

@Value("${book.name}")
String bookName;

book.name=《三体》

@PropertySource("classpath:com/hgs/hello/test/test.propertie")

<------------------------------jdk1.7版本-------------------------------------->
private static final sun.misc.Unsafe UNSAFE;  
// Segment数组第一个元素的地址相对于该对象实例起始地址的偏移量
private static final long SBASE;    
// Segment数组中元素element基本类型大小的移位量，比如我们要在i位置加入元素，
//用unsafe.putOrderedObject(segments, (i << SSHIFT) + SBASE, element);
private static final int SSHIFT;  
//HashEntry数组第一个元素的地址相对于该对象实例起始地址的偏移量  
private static final long TBASE;  
//HashEntry数组中元素基本类型大小的移位量
private static final int TSHIFT;  
// ConcurrentHashMap属性hashSeed,segmentShift,segmentMask,segments的相对实例地址的偏移量
private static final long HASHSEED_OFFSET;  
private static final long SEGSHIFT_OFFSET;  
private static final long SEGMASK_OFFSET;  
private static final long SEGMENTS_OFFSET;  
  
static {  
    int ss, ts;  
    try {  
        UNSAFE = sun.misc.Unsafe.getUnsafe();  
        Class tc = HashEntry[].class;  
        Class sc = Segment[].class;  
        //获取数组中第一个元素的偏移量(get offset of a first element in the array)  
        TBASE = UNSAFE.arrayBaseOffset(tc);  
        SBASE = UNSAFE.arrayBaseOffset(sc); 
        //获取数组中一个元素的大小(get size of an element in the array)  
        ts = UNSAFE.arrayIndexScale(tc);  
        ss = UNSAFE.arrayIndexScale(sc); 
      //其中hashSeed = randomHashSeed(this)，随机一个hashSeed，用于key的hash计算
        HASHSEED_OFFSET = UNSAFE.objectFieldOffset(ConcurrentHashMap.class.getDeclaredField("hashSeed"));  
        SEGSHIFT_OFFSET = UNSAFE.objectFieldOffset(ConcurrentHashMap.class.getDeclaredField("segmentShift"));  
        SEGMASK_OFFSET = UNSAFE.objectFieldOffset(ConcurrentHashMap.class.getDeclaredField("segmentMask"));  
        SEGMENTS_OFFSET = UNSAFE.objectFieldOffset(ConcurrentHashMap.class.getDeclaredField("segments"));  
    } catch (Exception e) {  
        throw new Error(e);  
    }  
    if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0)  
        throw new Error("data type scale not a power of two");   
    SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);  
    TSHIFT = 31 - Integer.numberOfLeadingZeros(ts);  
} 
<---------------------------------jdk1.8版本--------------------------------->
// Unsafe mechanics
    private static final sun.misc.Unsafe U;
    private static final long SIZECTL;
    private static final long TRANSFERINDEX;
    private static final long BASECOUNT;
    private static final long CELLSBUSY;
    private static final long CELLVALUE;
    private static final long ABASE;
    private static final int ASHIFT;

    static {
        try {
            U = sun.misc.Unsafe.getUnsafe();
            Class<?> k = ConcurrentHashMap.class;
            SIZECTL = U.objectFieldOffset
                (k.getDeclaredField("sizeCtl"));
            TRANSFERINDEX = U.objectFieldOffset
                (k.getDeclaredField("transferIndex"));
            BASECOUNT = U.objectFieldOffset
                (k.getDeclaredField("baseCount"));
            CELLSBUSY = U.objectFieldOffset
                (k.getDeclaredField("cellsBusy"));
            Class<?> ck = CounterCell.class;
            CELLVALUE = U.objectFieldOffset
                (ck.getDeclaredField("value"));
            Class<?> ak = Node[].class;
            ABASE = U.arrayBaseOffset(ak);
            int scale = U.arrayIndexScale(ak);
            if ((scale & (scale - 1)) != 0)
                throw new Error("data type scale not a power of two");
            ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    //默认loadFactor=DEFAULT_LOAD_FACTOR=0.75f
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    //默认concurrencyLevel=DEFAULT_CONCURRENCY_LEVEL=16，
    //MAX_SEGMENTS =1<<16即数组segments的最大长度，也是最大并发级别；
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;

    //保证concurrencyLevel是2^n，默认ssize=16；
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    //定位Segment的index时hash值的移位,默认时候sshift=4,segmentShift=32-4=28；
    segmentShift = 32 - sshift; 
    //用于& 运算定位Segment的index，默认构造时是0x0f(十进制也就是15)
    segmentMask = ssize - 1;
    this.segments = Segment.newArray(ssize);
    
    //默认initialCapacity=DEFAULT_INITIAL_CAPACITY=16
    //MAXIMUM_CAPACITY=1<<30
    if (initialCapacity > MAXIMUM_CAPACITY) 
        initialCapacity = MAXIMUM_CAPACITY;
    //确定每个segment初始化时候有多少个hash桶，并保证为2^n,默认cap = 1,但是之后每个segment构造完成后这个cap值就没用了。
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = 1;
    while (cap < c)
        cap <<= 1;
  //确定cap后开始初始化每个segment的table
    for (int i = 0; i < this.segments.length; ++i)
        this.segments[i] = new Segment< K,V > (cap, loadFactor);
}

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY),
         DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    putAll(m);
}

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {  
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)  
        throw new IllegalArgumentException();  
    if (concurrencyLevel > MAX_SEGMENTS)  
        concurrencyLevel = MAX_SEGMENTS;  
    // Find power-of-two sizes best matching arguments  
    int sshift = 0;  
    int ssize = 1;  
    while (ssize < concurrencyLevel) {  
        ++sshift;  
        ssize <<= 1;  
    }  
    this.segmentShift = 32 - sshift;  
    this.segmentMask = ssize - 1;  
    if (initialCapacity > MAXIMUM_CAPACITY)  
        initialCapacity = MAXIMUM_CAPACITY;  
    int c = initialCapacity / ssize;  
    if (c * ssize < initialCapacity)  
        ++c;  
    //cap = MIN_SEGMENT_TABLE_CAPACITY = 2，即每个segment容量最小初始化为2，
    //而jdk1.6默认cap=1
    int cap = MIN_SEGMENT_TABLE_CAPACITY;  
    while (cap < c)  
        cap <<= 1;  
    //与jdk1.6不同点，这里只是构造一个segments和segments[0],懒加载
    Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[])new HashEntry[cap]);  
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];  
    //这里用UNSAFE给数组ss第一个元素赋值，内存非立即可见
    UNSAFE.putOrderedObject(ss, SBASE, s0);  
    this.segments = ss;  
}  
// 其余的几个同上