//可标记方法和类
@Target({ElementType.METHOD, ElementType.TYPE})
//运行时生效
@Retention(RetentionPolicy.RUNTIME)
//自动继承
@Inherited
@Documented
public @interface Transactional {

	//指定TransactionManager
	@AliasFor("transactionManager")
	String value() default "";

  //指定TransactionManager
	@AliasFor("value")
	String transactionManager() default "";
	//指定事务传播设置
	Propagation propagation() default Propagation.REQUIRED;

	//指定事务隔离级别
	Isolation isolation() default Isolation.DEFAULT;

  //指定超时时间
	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

  //标记只读事务
	boolean readOnly() default false;
    
	//指定回滚的异常类型
	Class<? extends Throwable>[] rollbackFor() default {};

	String[] rollbackForClassName() default {};
	
  //指定不会滚的异常类型
	Class<? extends Throwable>[] noRollbackFor() default {};

	String[] noRollbackForClassName() default {};

}

public enum Propagation {
    //REQUIRED必须有事务，也就是说当前线程有事务就用，没有就New一个
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

   //支持事务，即有事务就用，没有就不用
	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

  //强制事务，必须有，没有就抛异常
	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

  //必须new事务
	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

  //非事务操作，暂停当前事务，只对分布式JtaTransactionManager有效
	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

  //不能在事务内执行，存在事务则抛异常
	NEVER(TransactionDefinition.PROPAGATION_NEVER),
    //嵌套事务(JDBC3.0 DataSourceTransactionManager下有效)
	NESTED(TransactionDefinition.PROPAGATION_NESTED);
    
	//省略
}

public class HkpClientHandler extends SimpleChannelInboundHandler<MessagePackage> {
	private BlockingQueue<Object> response = new ArrayBlockingQueue<Object>(1);

	@Override
	protected void channelRead0(ChannelHandlerContext ctx, MessagePackage msg) throws Exception {
		response.add(msg.getXmlMessage());
		ctx.close();
	}
	public String getResponse() throws InterruptedException {
  		Object result = response.take();
  		if (result instanceof Throwable) {
  			Throwable cause = (Throwable) result;
  			throw new ServerException(ResponseCode.FAIL, cause);
  		}
  		return (String) result;
  	}
  	//省略
}

public class HkpClientInitializer extends ChannelInitializer<SocketChannel> {
	private HkpClientHandler clientHandler = new HkpClientHandler();

	@Override
	protected void initChannel(SocketChannel ch) throws Exception {
		ChannelPipeline pipeline = ch.pipeline();

		pipeline.addLast(new LoggingHandler());
		pipeline.addLast("MessageDecoder", new MessagePackageDecoder(1024 * 1024, 4, 4, -8, 0));
		pipeline.addLast("MessageEncoder", new MessagePackageEncoder());
		pipeline.addLast("ReadTimeout", new ReadTimeoutHandler(5));
		// 客户端的逻辑
		pipeline.addLast("handler", clientHandler);
	}
	public String getResponse() throws InterruptedException {
  		return clientHandler.getResponse();
  	}
}

Object result = response.poll(8, TimeUnit.SECONDS);
if (result == null){
    throw new ServerException("Timeout recieving response from remote!");
}

public interface Lock {
    //获取锁
    void lock();
    //获取锁过程中监听中断状态
    void lockInterruptibly() throws InterruptedException;
    //尝试获取锁，立即返回true或false
    boolean tryLock();
    //一定时间内尝试获取锁，允许中断
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    //释放锁，一般在finally中
    void unlock();
    //返回一个新建的Condition，用于实现wait/signal机制，释放锁并等待唤醒；应用：阻塞队列、CyclicBarrier、线程池等
    Condition newCondition();
}

public class ReentrantLock implements Lock, java.io.Serializable {

      public ReentrantLock(boolean fair) {
          sync = fair ? new FairSync() : new NonfairSync();
      }
      
      public int getHoldCount() {
          return sync.getHoldCount();
      }
      public boolean isHeldByCurrentThread() {
          return sync.isHeldExclusively();
      }
      public boolean isLocked() {
          return sync.isLocked();
      }
      public final boolean hasQueuedThreads() {
         return sync.hasQueuedThreads();
     }
     public final boolean hasQueuedThread(Thread thread) {
         return sync.isQueued(thread);
     }
     public final int getQueueLength() {
         return sync.getQueueLength();
     }
     protected Collection<Thread> getQueuedThreads() {
         return sync.getQueuedThreads();
     }
     public boolean hasWaiters(Condition condition) {
         if (condition == null)
             throw new NullPointerException();
         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
             throw new IllegalArgumentException("not owner");
         return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
     }
     public int getWaitQueueLength(Condition condition) {
         if (condition == null)
             throw new NullPointerException();
         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
             throw new IllegalArgumentException("not owner");
         return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
     }
     protected Collection<Thread> getWaitingThreads(Condition condition) {
         if (condition == null)
             throw new NullPointerException();
         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
             throw new IllegalArgumentException("not owner");
         return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
     }
}