JDK1.8 HashMap存储结构由链表改成了平衡树，复杂度 o(n) –> o(log n).看来还是应该跟进最新版。

million 10^ 6
billion 10^ 9
trillion 10^ 12
quadrillion 10^ 15
quintillion 10^ 18
sextillion 10^ 21
septillion 10^ 24
octillion 10^ 27
nonillion 10^ 30
decillion 10^ 33
undecillion 10^ 36
duodecillion 10^ 39
tredecillion 10^ 42
quattuordecillion 10^ 45
quindecillion 10^ 48
sexdecillion 10^ 51
septendecillion 10^ 54
octodecillion 10^ 57
novemdecillion 10^ 60
vigintillion 10^ 63
unvigintillion 10^ 66
duovigintillion 10^ 69
trevigintillion 10^ 72
quattuorvigintillion 10^ 75
quinvigintillion 10^ 78
sexvigintillion 10^ 81
septenvigintillion 10^ 84
octovigintillion 10^ 87
novemvigintillion 10^ 90
trigintillion 10^ 93
untrigintillion 10^ 96
duotrigintillion 10^ 99
tretrigintillion 10^102
quattuortrigintillion 10^105
quintrigintillion 10^108
sextrigintillion 10^111
septtrigintillion 10^114
octotrigintillion 10^117
novemtrigintillion 10^120
quardragintillion 10^123
unquardragintillion 10^126
duoquardragintillion 10^129
trequardragintillion 10^132
quattuorquardragintillion 10^135
quinquardragintillion 10^138
sexquardragintillion 10^141
septquardragintillion 10^144
octoquardragintillion 10^147
novemquardragintillion 10^150
quinquagintillion 10^153
unquinquagintillion 10^156
duoquinquagintillion 10^159
trequinquagintillion 10^162
quattuorquinquagintillion 10^165
quinquinquagintillion 10^168
sexquinquagintillion 10^171
septquinquagintillion 10^174
octoquinquagintillion 10^177
novemquinquagintillion 10^180
sexagintillion 10^183
unsexagintillion 10^186
duosexagintillion 10^189
tresexagintillion 10^192
quattuorsexagintillion 10^195
quinsexagintillion 10^198
sexsexagintillion 10^201
septsexagintillion 10^204
octosexagintillion 10^207
novemsexagintillion 10^210
septuagintillion 10^213
unseptuagintillion 10^216
duoseptuagintillion 10^219
treseptuagintillion 10^222
quattuorseptuagintillion 10^225
quinseptuagintillion 10^228
sexseptuagintillion 10^231
septseptuagintillion 10^234
octoseptuagintillion 10^237
novemseptuagintillion 10^240
octogintillion 10^243
unoctogintillion 10^246
duooctogintillion 10^249
treoctogintillion 10^252
quattuoroctogintillion 10^255
quinoctogintillion 10^258
sexoctogintillion 10^261
septoctogintillion 10^264
octooctogintillion 10^267
novemoctogintillion 10^270
nonagintillion 10^273
unnonagintillion 10^276
duononagintillion 10^279
trenonagintillion 10^282
quattuornonagintillion 10^285
quinnonagintillion 10^288
sexnonagintillion 10^291
septnonagintillion 10^294
octononagintillion 10^297
novemnonagintillion 10^300
centillion 10^303

最后。。。大家千万不要去玩 adventure capitalist

最近好奇做了一个测试，使用spring + mybatis 对mysql插入百条数据。
第一种，通过调用service一条一条插入，出错没有回滚。
结果耗时非常长，这也是很正常的。
第二种，在100w条sql跑在同一个事物中，好处就是这一百万条数据是原子性的。统一成功或者失败。
数据生成代码

                List<Log> logs = new ArrayList<Log>(100_0000);
		for (int i = 0; i < 100_0000; i++) {
			Log log = new Log();
			log.setAddress(Math.random()+"");
			log.setJingdu(Math.random()*100);
			log.setWeidu(Math.random()*100);
			log.setTokenId(UUID.randomUUID().toString().split("-")[0]);
			log.setSignDate(new Date());
			logs.add(log);
		}

批量插入代码

        public void insert(Iterable<Log> logs) {
		for (Log l : logs) {
			baseDao.insert(l);
		}
		
	}

结果：百万次，十次测试[679, 703, 620, 564, 698, 700, 678, 686, 711, 619]单位秒
第三种 拼接sql. insert into … values (…),(…),(….)
这种方式直接卡死。
第四种 batch update

@Override
	public void addBatch(final List<Log> item) {
		String sql = "insert into log (id, token_id, sign_date,jingdu, weidu, address)values (null,?,?,?,?, ?)";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {  
            // 为prepared statement设置参数。这个方法将在整个过程中被调用的次数  
            public void setValues(PreparedStatement pst, int i)  
                    throws SQLException {  
            	Log log = item.get(i);
                pst.setString(1, log.getTokenId());  
                pst.setDate(2,new java.sql.Date(log.getSignDate().getTime()) );
                pst.setDouble(3, log.getJingdu());
                pst.setDouble(4, log.getWeidu());
                pst.setString(5, log.getAddress());  
            }  
  
            // 返回更新的结果集条数  
            public int getBatchSize() {  
                return item.size();  
            }  	
        });  
	}

结果[211, 216, 243, 234, 235, 238, 237, 224, 222, 226]秒
目前来看还是batchUpdate的效率最高。

今天测试了下插入性能发现用注解配置的事物不回滚，仔细找了找原因。
首先确认了下配置是对的。

	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 使用annotation定义事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"
		proxy-target-class="true" />

然后检查注解

@Service
@Transactional(propagation=Propagation.REQUIRED) 
public interface LogService extends BaseService<Log>{
	Log dataToLog(Data data);
	
	Log selectLostContact(Date date);
	
	void insert(Iterable<Log> logs);
	
	void addBatch(List<Log> item);
}

发现都没啥问题。然后把propagation改成了只读，发现还能提交。说明事物根本没配置成功。然后把注解放到实现类上试了下。发现可以了，事物正常了，回滚也正常了。md….原来接口上的注解不继承。。。
spring版本4.0.1

备案终于下来了，可以使用国内的服务器了，以后aws就专心做vpn好了，服务器大部分已经迁移完毕了。还有一些java项目没有挪过来，也会尽快挪过来。不知道证书续期还麻不麻烦，到时候再说吧。

经过这么长时间，我发现，博客，就应该，少写点没用的。

本服务器架构 nginx做反向代理php + tomcat以后也可能用jetty。数据库使用的是mysql。没有做redius。

本站依然可以使用 https和http两种协议访问

最近用了免费一年的亚马逊云打了个VPN,速度非常快

http://www.amazonaws.cn/ <—亚马逊云申请

http://my.oschina.net/isnail/blog/363151  <—蜗牛学长的搭建教程

大家注意下用户名密码不要写错了~