其实代码是比较简单的，相信这段代码还是有很多用处的。
可以使用到的场景有：

• 设置在某一时刻之前，必须更新缓存里的数据；
• 在Quartz中，统计和分析昨天的数据；
• 合并某一天内发生的动态；
• ……

http://sacc.it168.com/

部分PPT下载地址：
1、架构师大会－架构设计专场

http://linux.chinaunix.net/SACC2010/topic1.zip

2、架构师大会－架构设计与存储管理专场

http://linux.chinaunix.net/SACC2010/topic2.zip

3、架构师大会－应用系统优化与流量管理

http://linux.chinaunix.net/SACC2010/topic3.zip

4、架构师大会－可扩展数据库架构

http://linux.chinaunix.net/SACC2010/topic4.zip

5、架构师大会－移动互联网产品架构设计

http://linux.chinaunix.net/SACC2010/topic5.zip

6、架构师大会－系统安全与服务监控

http://linux.chinaunix.net/SACC2010/topic6.zip

7、架构师大会－云计算分布式应用实践

http://linux.chinaunix.net/SACC2010/topic7.zip

CallerRunsPolicy【重要的任务】

当异步线程池满了时，使用阻塞式，丢弃异步的方式执行，此策略比较保守，不丢弃，不放弃。

AbortPolicy【不太重要，但需要监控的任务】

中止任务，并抛出异常。

DiscardPolicy【满足最先请求的任务】

丢弃当前线程，也就是新来的任务丢弃掉。

DiscarOldestPolicy【满足最后请求的任务】

丢弃任务列队里最老的线程。

对于ThreadPoolExecutor来说，还有关注的地方是，他有3种列队。

• SynchronousQueue
• LinkedBlockingQueue
• ArrayBlockingQueue

	<!-- 压缩JS，CSS -->
	<target name="compress">
		<apply executable="java" parallel="false" failonerror="true">
			<fileset dir="${html-js}" includes="**/*.js" />
			<arg line="-jar" />
			<arg path="${yui-compressor}" />
			<arg line="--charset utf-8" />
			<srcfile />
			<arg line="-o" />
			<mapper type="glob" from="*.js" to="${webhtml-js}/*-min.js" />
			<targetfile />
		</apply>
		<apply executable="java" parallel="false" failonerror="true">
			<fileset dir="${html-css}" includes="**/*.css" />
			<arg line="-jar" />
			<arg path="${yui-compressor}" />
			<arg line="--charset utf-8" />
			<srcfile />
			<arg line="-o" />
			<mapper type="glob" from="*.css" to="${webhtml-css}/*-min.css" />
			<targetfile />
		</apply>
	</target>

2、更新JSS/CSS版本号

	<!-- 更新静态文件的版本号 -->
	<target name="version">
		<tstamp>
			<format property="TIMESTAMP" pattern="yyyyMMddHHmmss" locale="en" />
		</tstamp>
		<loadfile property="svn.version" srcFile="./.svn/entries">
			<filterchain>
				<headfilter lines="1" skip="3" />
				<deletecharacters chars="\n" />
			</filterchain>
		</loadfile>
		<delete file="${webinf-ftl}/config.ftl"/>
		<copy file="${ftl-app}/config.ftl" tofile="${webinf-ftl}/config.ftl" />
		<replace file="${webinf-ftl}/config.ftl" token="$version$" value="${svn.version}" />
	</target>

接下来就是合并JS/CSS文件

	<!-- 合并静态文件 -->
	<target name="js-concat">
		<concat destfile="${webhtml-js}/jquery.js" encoding="utf-8" append="false">
			<path path="${webhtml-js}/jquery.core-min.js" />
			<path path="${webhtml-js}/jquery.cookie-min.js" />
			<path path="${webhtml-js}/jquery.timeago-min.js" />
			<path path="${webhtml-js}/jquery.utils-min.js" />
			<path path="${webhtml-js}/jquery.watermarkinput-min.js" />
		</concat>
	</target>

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * MemcacheMap 保存的对象
 *
 * @author Herbert
 *
 */
public class MemcacheMapVO implements Serializable {
	/**
	 *
	 */
	private static final long serialVersionUID = 2719454259953108119L;

	/**
	 * value
	 */
	private Object value;

	/**
	 * 过期时间
	 */
	private Long expires;

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}

	public Long getExpires() {
		return expires;
	}

	public void setExpires(Long expires) {
		this.expires = expires;
	}

	public int size() {
		try {
			ByteArrayOutputStream buf = new ByteArrayOutputStream();
			ObjectOutputStream o = new ObjectOutputStream(buf);
			o.writeObject(this.value);
			byte[] bytes = buf.toByteArray();
			return bytes.length * 8;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return 0;
	}
}

MemcacheMapUtil.java

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Map.Entry;

import com.netease.photo.share.meta.vo.MemcacheMapVO;

/**
 * 用JAVA实现简单的Memcached功能<br>
 *
 * @author Herbert
 *
 */
public final class MemcacheMapUtil {
	private MemcacheMapUtil() {

	}

	public static final int MINUTES = 60;

	/**
	 * MAP个数
	 */
	private static final long MAXSIZE = 3000;

	/**
	 * 安全个数
	 */
	private static final long SAFESIZE = 2800;

	/**
	 * 最大时间
	 */
	private static final int MAXTIME = 24 * 60 * 60 * 1000;

	/**
	 * 存储的值
	 */
	private static HashMap<String, MemcacheMapVO> memcacheMap = new HashMap<String, MemcacheMapVO>();

	/**
	 * 得到值
	 *
	 * @param key
	 *
	 * @return
	 */
	public static Object get(final String key) {
		MemcacheMapVO memcacheMapVO = memcacheMap.get(key);
		long now = new Date().getTime();
		// 判断是否有这个值存在
		if (memcacheMapVO == null) {
			return null;
			// 判断保存的值是否过期
		} else if (now >= memcacheMapVO.getExpires()) {
			memcacheMap.remove(key);
			return null;
		} else {
			return memcacheMapVO.getValue();
		}
	}

	/**
	 * 删除值
	 *
	 * @param key
	 */
	public static void delete(final String key) {
		memcacheMap.remove(key);
	}

	/**
	 *
	 * @param key
	 *            对象的KEY
	 * @param value
	 *            对象的值
	 * @param seconds
	 *            对象的有效时间
	 */
	public static void set(final String key, final Object value, final int seconds) {
		// 清理工作
		int count = memcacheMap.size();
		if (count <= MemcacheMapUtil.SAFESIZE) {
			// 小于安全个数，不需要清理
		} else if (count > MemcacheMapUtil.SAFESIZE) {
			// 大于安全个数，按时间清理
			checkMemcacheMap();
			if (count >= MemcacheMapUtil.MAXSIZE) {
				// 清理后无效，进行强制清理
				clearMemcacheMap();
			}
		}
		// 增加值的工作
		MemcacheMapVO memcacheMapVO = new MemcacheMapVO();
		memcacheMapVO.setValue(value);
		long now = new Date().getTime();

		long expires = seconds * 1000;
		if (expires >= MAXTIME) {
			expires = MAXTIME;
		}
		expires += now;
		memcacheMapVO.setExpires(expires);
		memcacheMap.put(key, memcacheMapVO);
	}

	/**
	 * 默认保存时间为12小时
	 *
	 * @param key
	 * @param value
	 */
	public static void set(final String key, final Object value) {
		set(key, value, 12 * 60 * 60);
	}

	/**
	 * 产生一个KEY
	 *
	 * @param methodName
	 *            方法名
	 * @param parameters
	 *            参数列表
	 */
	public static String createKey(String methodName, Object... parameters) {
		String str = methodName;
		for (Object obj : parameters) {
			str += "_" + obj.toString();
		}
		return str;
	}

	/**
	 * 强制清理到安全值
	 */
	private static void clearMemcacheMap() {
		// 清除
		long clearCount = MemcacheMapUtil.MAXSIZE - MemcacheMapUtil.SAFESIZE;
		String[] keys = (String[]) memcacheMap.keySet().toArray();
		int keyCount = keys.length;
		Random random = new Random();
		for (int i = 0; i < clearCount; i++) {
			int randomIndex = random.nextInt(keyCount);
			String key = keys[randomIndex];
			delete(key);
		}
	}

	/**
	 * 检查过期的对象
	 */
	private static void checkMemcacheMap() {
		// 这种迭代的方式节约了一次迭代
		Iterator<Entry<String, MemcacheMapVO>> iterator = memcacheMap.entrySet().iterator();
		long now = new Date().getTime();
		while (iterator.hasNext()) {
			Map.Entry<String, MemcacheMapVO> entry = (Map.Entry<String, MemcacheMapVO>) iterator.next();
			String key = (String) entry.getKey();
			MemcacheMapVO memcacheMapVO = entry.getValue();
			if (now >= memcacheMapVO.getExpires()) {
				memcacheMap.remove(key);
			}
		}
	}
}

这次迁移Exif信息，数据有4亿的数据，为了不影响另外一个系统，采用单节点数据文件迁移（具体还有很多因素）。
首先是拆分数据文件为小文件，即使程序错误或者其它中断，也只影响少量数据，重新迁移的话，只有少量数据是空转。
当然使用小文件还有个原因是考虑到要记录没有处理的数据，所以这些文件数据是要读到内存中去的。
还有就是可以做到多进程多线程迁移数据，只有你的数据库足够强大，抗得住压力。
此过程中可以以文件为单位，采用多线程操作，可以提高速度。

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(15, 100, 1, TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(10), new ThreadPoolExecutor.DiscardOldestPolicy());

这个线程池当处理不过来时，会丢弃任务，所以我是采用这样的方式解决这个问题的。

			while (threadPool.getPoolSize() > 80) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

得到Java进程的PID

String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];

迁移的效率还是比较高，导致数据库扛不住了，必须在白天放慢迁移速度。

刚毕业后找了个小工作，自己摸爬滚打了好一整子，一顿瞎搞，虽然也有点小成，但总觉得想学到很多，想施展更多。

在这样的一个情况下，我加入了这个项目，虽然有件事情来得太突然，自己都没有预料到，但总归一切变好，自己始终没有放弃，一直低调的坚持下来，所以我很感谢当时在我身边的每一个人的关怀。

完整的经历了整个项目，虽然这个项目只有两年，但足以让我全盘把握，了解了并掌握了整个项目的开发，受益匪浅，估计还可以使用好几年：）

其实项目本身好无价值，贵在我们在项目上所花费的心血，所赋予的期望和所得到的回报，所以这是我人生的一个转折点，我踏进了项目开发的大门。

下面会分小块来讲解我的感悟：

1. 团队建设
2. 系统开发
3. 系统运维

#!/bin/sh
TOP_SYS_LOAD_NUM=5
SYS_LOAD_NUM=`uptime | awk '{print $(NF-2)}' | sed 's/,//'`

echo $(date +"%y-%m-%d") `uptime`
if [ `echo "$TOP_SYS_LOAD_NUM < $SYS_LOAD_NUM"|bc` -eq 1 ]
then
    echo "##" $(date +"%y-%m-%d %H:%M:%S") "pkill httpd" `ps -ef | grep httpd | wc -l`
    pkill httpd
	sleep 10
	for i in 1 2 3
    do
		if [ `pgrep httpd | wc -l` -le 0 ]
		then
			/home/app/httpd/bin/apachectl start
			sleep 30
			echo "##" $(date +"%y-%m-%d %H:%M:%S") "start httpd" `ps -ef | grep httpd | wc -l`
		fi
	done
else
	if [ `pgrep httpd | wc -l` -le 0 ]
	then
		/home/app/httpd/bin/apachectl start
		sleep 30
		echo "##" $(date +"%y-%m-%d %H:%M:%S") "start httpd" `ps -ef | grep httpd | wc -l`
	fi
fi

然后在crontab里增加定时执行的命令

*/2 * * * * (/root/checkload.sh >>/root/checkload.log)

每两分钟检查一次系统负载。