七段

无论怎样，请让我先感谢一下国家。
BlogJava 首页 新随笔 联系 聚合 管理
  35 Posts :: 2 Stories :: 7 Comments :: 0 Trackbacks

2010年4月17日 #

有25匹马，每匹马都以一个固定不变的速度奔跑，每匹马的速度都不一样，如果让你找出跑的最快的5匹马，最少需要组织多少场比赛？注：每场比赛最多只能5匹马参赛。
有25匹马，每匹马都以一个固定不变的速度奔跑，每匹马的速度都不一样，如果让你找出跑的最快的5匹马，最少需要组织多少场比赛？注：每场比赛最多只能5匹马参赛。
re:悲观10场，乐观7场。
posted @ 2012-03-07 21:17 sevenduan 阅读(812) | 评论 (1) | 编辑 收藏

Really Useful Shortkey
Eclipse:
ctrl+o
ctrl+space
ctrl+t
ctrl+k
ctrl+f8/f9/f10

alt+shift+x , t/j
alt+shift+d , t/j

Command:
cd -
tab
ctrl+a/e
ctrl+u/k/w

Vim
shift+g
m+'mark'
`+'mark'
. (repeat)



posted @ 2010-08-07 23:14 sevenduan 阅读(228) | 评论 (0) | 编辑 收藏

Java logging framework
Framework Supported log levels Standard appenders Popularity Cost / licence
Log4J FATAL ERROR WARN INFO DEBUG TRACE AsyncAppender, JDBCAppender, JMSAppender, LF5Appender, NTEventLogAppender, NullAppender, SMTPAppender, SocketAppender, SocketHubAppender, SyslogAppender, TelnetAppender, WriterAppender Widely used in many project and platforms Apache License, Version 2.0
Java Logging API SEVERE WARNING INFO CONFIG FINE FINER FINEST Depends on the underlying framework; Sun's default Java Virtual Machine (JVM) has the following: ConsoleHandler, FileHandler, SocketHandler, MemoryHandler Not widely used[citation needed] Comes with the JRE
Apache Commons Logging FATAL ERROR WARN INFO DEBUG TRACE Depends on the underlying framework Widely used, in conjunction with log4j Apache License, Version 2.0
SLF4J ERROR WARN INFO DEBUG TRACE Depends on the underlying framework, which is pluggable Probably small but growing MIT License
posted @ 2010-07-18 22:15 sevenduan 阅读(465) | 评论 (0) | 编辑 收藏

java transaction summary

1 definition:

“A transaction is a complete unit of work. It may comprise many computational tasks,which may include user interface, data retrieval, and communications. A typicaltransaction modifies shared resources.”

2 transaction features:
ACID (atomicity, consistency, isolation, durability)

3 java spec
JTA, JTS
 1interface javax.transaction.TransactionManager
 2{
 3public abstract void begin();
 4public abstract void commit();
 5public abstract int getStatus();
 6public abstract Transaction getTransaction();
 7public void resume(Transaction tobj);
 8public abstract void rollback();
 9public abstract void setRollbackOnly();
10public abstract void setTransactionTimeout(intseconds);
11public abstract Transaction suspend() ;
12}

4 Common XAResource
JDBC 2.0:
A JDBC driver that supports distributed transactions implements the javax.transaction.xa.XAResource interface, the javax.sql.XAConnectioninterface, and the  javax.sql.XADataSource interface.

JMS 1.0:

a JMS provider javax.transaction.xa.XAResource interface, the implements the javax.jms.XAConnection and the javax.jms.XASession interface.

5 Common TransactionManager

5.1 EJB Transaction Options:
NotSupported
    If the method is called within a transaction, this transaction is suspended during the time of the method execution.
Required
    If the method is called within a transaction, the method is executed in the scope of this transaction; otherwise, a new transaction is started for the execution of the method and committed before the method result is sent to the caller.
RequiresNew
    The method will always be executed within the scope of a new transaction. The new transaction is started for the execution of the method, and committed before the method result is sent to the caller. If the method is called within a transaction, this transaction is suspended before the new one is started and resumed when the new transaction has completed.
Mandatory
    The method should always be called within the scope of a transaction, else the container will throw the TransactionRequired exception.
Supports
    The method is invoked within the caller transaction scope; if the caller does not have an associated transaction, the method is invoked without a transaction scope.
Never
    The client is required to call the bean without any transaction context; if it is not the case, a java.rmi.RemoteException is thrown by the container.

5.2 Spring transaction:
      Transaction isolation: The degree of isolation this transaction has from the work of other transactions. For example, can this transaction see uncommitted writes from other transactions? avaliable options:
ISOLATION_DEFAULT
ISOLATION_READ_UNCOMMITTED
ISOLATION_READ_COMMITTED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE

      Transaction propagation: Normally all code executed within a transaction scope will run in that transaction. However, there are several options specifying behavior if a transactional method is executed when a transaction context already exists: For example, simply running in the existing transaction (the most common case); or suspending the existing transaction and creating a new transaction. Spring offers the transaction propagation options familiar from EJB CMT. avaliable options:
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS

      Transaction timeout: How long this transaction may run before timing out (automatically being rolled back by the underlying transaction infrastructure).
      Read-only status: A read-only transaction does not modify any data. Read-only transactions can be a useful optimization in some cases (such as when using Hibernate).


6 transaction for web service
Protocol specifications:
WS-Transaction
OASIS Business Transaction Protocol (BTP)
Java API
JAXTX (JSR-156)

 

posted @ 2010-04-25 16:44 sevenduan 阅读(594) | 评论 (0) | 编辑 收藏

java nest class and java inner class
JavaScript里有两个容易让初学者混淆的概念：scope chain and closure。
比如说，我想创建10个函数，每个函数依次返回0-9.
 1 //wrong: all function refer to global variable i=10 
 2 var fn_list=[];
 3 for(var i=0;i<10;i++){
 4  var _tempFn =function(){
 5         return i;
 6  }
 7  fn_list.push(_tempFn);    
 8 }
 9 //right: every function refer to its closure scope variable a
10 var fn_list=[];
11 for(var i=0;i<10;i++){
12  var _tempFn =function(a){
13         return function(){
14          return a;
15         };
16  }
17  fn_list.push(_tempFn(i));    
18 }
19 

Java里也有两个让初学者容易混淆的概念：nest class and inner class。
nest class就是static inner class,
而inner class就是no-static inner class。没有为什么，sun就是这么定义的。
还是上面得例子，创建10个对象，每个对象的getValue接口依次返回0-9.
 1 public class Test {
 2     private int noStaticValue;
 3     private static int staticValue;
 4 
 5     public Test(int noSV, int sv) {
 6         this.noStaticValue = noSV;
 7         this.staticValue = sv;
 8     }
 9 
10     public Test(int noSV) {
11         this.noStaticValue = noSV;
12     }
13 
14     interface valueHolder {
15         int getValue();
16     }
17 
18     class innerClass implements valueHolder {
19         public int getValue() {
20             return noStaticValue;
21         }
22     }
23 
24     static class nestClass implements valueHolder {
25         public nestClass(int i) {
26             staticValue = i;
27         }
28 
29         public int getValue() {
30             return staticValue;
31         }
32     }
33 
34     public static void main(String[] args) {
35         Test context1 = new Test(0, 0);
36         valueHolder[] list = new valueHolder[10];
37         for (int i = 0; i < 10; i++) {
38             list[i] = new Test.nestClass(i);
39         }
40         for (valueHolder obj : list) {
41             System.out.println(obj.getValue());// always print 9
42         }
43         for (int i = 0; i < 10; i++) {
44             list[i] = new Test(i).new innerClass();
45         }
46         for (valueHolder obj : list) {
47             System.out.println(obj.getValue());// print 0-9
48         }
49     }
50 }
可见用inner class可以模拟closure的特性，就是运行时定义class的某些状态。
inner class和nest class之间的区别就是后者是静态类。前者必须通过wrap class的实例来调用new,e.g. new Test().new innerClass。
因为nest class是静态类，所以可以添加static member 或者static method,而inner class 不行。
匿名内部类是inner class的一种特殊形式，所以也不能添加static member 或者static method。



posted @ 2010-04-17 23:07 sevenduan 阅读(2763) | 评论 (5) | 编辑 收藏