#
基本的ThreadLocal使用
public class ThreadLocalTest {
static ThreadLocal tl=new ThreadLocal();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
int data =new Random().nextInt();
public void run() {
System.out.println(Thread.currentThread().getName()+"存入的数据是 "+data);
tl.set(data); //存到了当前线程
new A().getThreadData();
}
}).start();
}
}
static class A{ //静态类相当于一个外部类
public void getThreadData(){
System.out.println("data is "+tl.get());
}
}
}
结果可能是
Thread-0存入的数据是 1997234255
Thread-1存入的数据是 267171693
data is 1997234255
data is 267171693
通过包装对象非常烂的使用方式
class MyThreadScopeData{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class ThreadLocalTest {
static ThreadLocal<MyThreadScopeData> myThreadScopeData=
new ThreadLocal<MyThreadScopeData>();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
int data =new Random().nextInt();
public void run() {
MyThreadScopeData mydata=new MyThreadScopeData();
mydata.setName("name is name"+data);
mydata.setAge(data);
//把对象存入ThreadLocal 这样的做法非常烂！！！！！
myThreadScopeData.set(mydata);
new B().showThreadScopeData();
}
}).start();
}
}
static class B{
public void showThreadScopeData(){
System.out.println(myThreadScopeData.get().getName());
System.out.println("age is "+myThreadScopeData.get().getAge());
}
}
}
}
标准使用方式
/**
* 单列线程
* 在线程中范围内任意地方调，得到都是同一个实例对象
* 把ThreadLocal封装到单列的内部
*/
class ThreadSingle{
private ThreadSingle(){}
public static ThreadLocal<ThreadSingle> map=new ThreadLocal<ThreadSingle>();
//不需要加synchronized，即便有第2个线程进入，但拿到的map.get()是独有的。
public static ThreadSingle getThreadInstance(){ //方法得到是与本线程相关的实例
ThreadSingle obj=map.get();
/**
* 如果A进入时obj=null，刚创建完还没赋值，此时B线程进入，但B和A没有关系。
*/
if(obj==null){
obj=new ThreadSingle();
map.set(obj);
}
return obj;
}
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class ThreadLocalTest {
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
int data =new Random().nextInt();
public void run() {
ThreadSingle.getThreadInstance().setName("name"+data);
ThreadSingle.getThreadInstance().setAge(data);
new C().showData();
}
}).start();
}
}
在软件开发过程中，你经历的每件事情都会潜移默化地影响着你。随着时间的流逝，年纪的增长，对于程序开发技术（相同/或者相关能力）以及自身的理解也会不断沉淀，这些最终也会帮助你达成目标——成为一名优秀的程序员。这里谈到的经历不仅限于程序员生涯里的里程碑，比如换工作、成为领导/经理或者自己创业。你所经历的每一份工作、每个项目（不论大小）、与团队成员的每次交流、甚至你实现的每一个程序模块，都会让你变得比以前更优秀、更有活力、更有见地。
在日常的工作当中不放过任何一点可以学习的新知识，会让你成为更加出色的程序员。我说的是重要的经验——你不必去关心琐碎的事情（比如每一次敲击键盘是否完美），重要的是把握好每一天的安排。如果你出去旅游归来发现两手空空毫无收获，你肯定认为这是在浪费时间。对于程序员生涯也是如此。如果你在完成一个项目或者实现了一个程序功能之后自己没有收获（比如，对软件开发的理解没有提高并且也没有学到什么新的技术），这同样也是一种浪费。
你可能会说，有些必须完成的工作对你而言是无聊的重复劳动，从中学不到任何东西。事实可能的确如此，但是这取决于你如何看待它。归根结底你需要自己创造成长的条件，在做事的时候需要保持创新。
从每一次的经历中汲取营养
首先，除了学习新的编程语言，掌握你钟爱的开发平台最新特性，你还需要提高自己的沟通技巧。其次，学习如何与别人一起工作，提高自己团队协作能力也很重要。接着，你还需要掌握领导能力、管理能力、如何自我激励、财务知识、行业专业知识、营销知识和组织知识。除此之外对所从事行业相关的内容最好也要有广泛的认识和理解。在学习的过程中不断将自己推向极限，最终你会不断提升成为优秀的程序员。
我想说的是，无论你做什么，都可以从上面列举的这些方面来对照自己，看哪些方面可以有所提高。有的时候你的机遇很好，接触的是最新的技术，采用的是对你而言崭新的开发流程，这时你不由自主地就开始学习和吸收新知识。而有的时候工作确实很乏味，如果你不会自己创造条件自我提升（从上面列举的方面找到可以提高的地方），你就只能做着机械劳动白白浪费了一次提高自己的好机会，以及自己宝贵的时间。
下面我通过一个例子来说明如何从平凡的工作中提高自己。比如说你是一个SQL大牛，有一项工作需要完成很多SQL，只有你是最佳人选。你很精于此道，表面上这项工作很枯燥而且你也不能从中学到什么。但是如果进一步来看，也许这项任务需要与别人配合完成，而你可能并不十分擅长与别人搭档或者沟通，这就是你提高自己的绝佳机会，你要做的就是发现这个机会。或者也许你也十分擅长与别人搭档工作，但是假如这次你的搭档可能连新手都算不上，这就是你提高培训技巧的绝佳机会，捎带地也让这位新人快速成长。
也许这些都没有发生，你在做着一件你闭着眼睛都可以完成的工作，为什么不尝试去更深入地了解和提高你使用的技术呢？也许你也可以就此机会提高一下你的打字技巧，这肯定没有什么坏处。如果你实在不想做这件无聊的工作，可以尝试和老板沟通一下把事情推掉，虽然这不在我们上面的讨论范围之内，你也可以尝试一下。也许沟通不能达到目的，但是你可以从尝试沟通当中锻炼一下自己的机智和勇气（如何在尴尬的情形下保持镇定），毕竟你不会为了推掉任务而去惹恼你的经理/领导:)。所以，如果你能从不同的角度看待一个任务，突然之间你会发现在成为优秀程序员的路上又迈进了一步。
如果你在原地踏步该怎么办？
有的时候你一直无法摆脱一些事情（似乎这些事情本来就是如此）。即使从各个角度看也无法从中找到一点可以提高的地方，这个时候你该怎们办？这个问题问的很好，但你应该问的不是这个问题。如果你真的觉得不能从工作中学习和成长，为什么你还在做这样的工作呢（这个才是你应该问的）？如果是因为经济的原因（比如你现在的收入很高），那么一定要确保不会为了短期利益而损害了未来的前途。如果是因为你舍不得团队里一起工作的同事，那么只要分析一下利弊就会知道，即使你不在这里工作了，你们依然还是好朋友。你只是离开了公司，但你们的友谊没有结束。
如果不是上述的原因，那你为什么还在做这样的工作呢？你应该意识到，你会因此丧失宝贵的机会。请记住，对你所做的每一件事情给出评价，看它是否能给你带来改变或者加深你对程序开发技术的理解。如果答案是否定的，你可以马上离开；如果答案是肯定的，那么（做这件事的时候）你不但能够从中获得满足感，而且每一天（而不仅仅是每一年）都会在技术和人格上朝着完美的境界迈进
程序员是一个比较特殊的群体，他们因为长期和电脑打交道所养成的性格和脾气也是比较相近的。当然，既然是人，当然是会有性格的，也是会有脾气的。下面，让我来看看10种能把程序惹毛了的事情。一方面我们可以看看程序员的共性，另一方面我们也可以看看程序员的缺点。无论怎么样，我都希望他们对你的日常工作都是一种帮助。
第十位 程序注释
程序注释本来是一些比较好的习惯，当程序员老手带新手的时候，总是会告诉新手，一定要写程序注释。于是，新手们当然会听从老手的吩咐。只不过，他们可能对程序注释有些误解，于是，我们经常在程序中看到一些如下的注释：
代码:
r = n/2; //r是n的一半
//循环，仅当r- n/r不大于t
while ((r-n/r) <=t){
r =0.5* (r-n/r); // 设置r变量
}
每当看到这样的注释只注释是什么，而不注释为什么，相信你一定会被惹火，这是谁写的程序注释啊?不找来骂一顿看来是不会解气了。程序注释应该是告诉别人你的意图和想法，而不是告诉别人程序的语法，这是为了程序的易读性和可维护性，这样的为了注释而注释的注释，分明不是在注释，而是在挑衅，惹毛别人当然毋庸置疑。
第九位 打断
正当程序沉浸于编程算法的思考，或是灵感突现正在书写程序的时候，但却遭到别人的打断，那是一件非常痛苦的事情，如果被持续打断，那可能会让人一下子就烦躁起来。打断别人的人在这种情况下是非常不礼貌的。被打断的人就像函数调用一下，当其返回时，需要重新恢复断点时的现场，当然，人不是电脑，恢复现场通常是一个很痛苦的过程，极端的情况下可能需要从头开始寻找思绪，然后一点一点地回到断点。
因此，我看到一些程序员在需要安静不被打扰的时候，要么会选择去一个没人找得到的地方，要么会在自己的桌子上方高挂一个条幅以示众人本人正执行内核程序，无法中断，请勿骚扰，谢谢！可见正在沉浸于工作的程序被打断是多么大的开销。自然，被打断所惹毛了的人也不在少数了。
第八位 需求变化
这个事情估计不用多说了。只要是程序员，面对需求变化的时候可能总是很无奈的。一次两次可能还能接受，但也顶不住经常变啊。据说敏捷开发中有一套方法论可以让程序员们享受需求的变化，不知道是真是假。不过，今天让你做一个书桌，明天让你把书桌改成餐桌，后天让你把餐桌改成双人床，大后天让你把床改成小木屋，然后把小木屋再改成高楼大厦。哎，是人都会被惹毛了的。那些人只用30分钟的会议就可以作出任何决定，但后面那几十个程序员需要搭上几百个小时的辛苦工作。如果是我，可能我也需要神兽草泥马帮助解解气了。
不过，这也正说明了，程序员并不懂得怎么和用户沟通，而用户也不懂得和程序员沟通，如果一个项目没有一个中间人(如：PM)在其中协调的话，那么整个项目可能就是鸡同鸭讲，用户和程序员都会被对方所惹毛了。如果要例举几个用户被惹毛的事情，估计程序员的那种一根筋的只从技术实现上思考问题的方法应该也能排进前5名。
第七位 经理不懂技术
外行领导内行的事例还少吗?领导一句话，无论对不对，都是对的，我们必需照做，那怕是多么愚蠢多么错误的决定，我们也得照做。程序员其实并不怕经理不懂技术，最怕的就是不懂技术的经理装着很懂技术。最可气的是，当你据理力争的挑站领导权威的时候，领导还把你视为异类。哎，想起这样的领导别说是骂人了，打人的冲动都有了。
其实，经理只不过是一个团队的支持者，他应该帮助团队，为团队排忧解难。而不是对团队发号施令。其实管理真的很简单，如果懂的话，就帮着做，如果不懂的话，就相信下属，放手让下属做。最怕的就是又不懂技术，还不信任下属的经理了。哎，这真是程序员的痛啊。
第六位 用户文档
用户文档本来不应该那么的令人害怕。这些文档记录了一切和我们所开发的软件有关的一些话题。因为我们并不知道我们所面对的用户的电脑操作基础是什么样的，所以，在写下这样的文档的时候，我们必需假设这个用户什么也不懂。于是，需要用最清楚，最漂亮的语言写下一个最丰富的文档。那怕一个拷贝粘贴的操作，可能我们都要分成五、六步来完成，那怕是一个配置IP地址的操作，我们也要从开始菜单开始一步一步的描述。对于程序员来说，他们在开发过程中几乎天天都在使用自己开发的软件，到最后，可能都有点吐了，但还得从最简单的部份写这些文档，当然容易令他们烦燥，让程序员来完成这样的文档可能效果会非常不好。所以，对于这样的用户文档，应该由专门的文档人员来完成和维护。
第五位 没有文档
正如上一条所说的，程序员本来就不喜欢写文档，而因为技术人员的表达能力和写作能力一般都不是太好，所以，文档写的也很烂。看看开源社区的文档可能就知道了。但是，我们可爱的程序员另一方面最生气的却是因为没有文档。当然，上面说的是用户的文档，这里我们说的是开发方面的文档，比如设计文档，功能规格，维护文档等等。不过，基本上都是一样的。反正，一方面，我们的程序员不喜欢写文档，另一方面，我们的程序又会被抱怨没有文档，文档太少，或者文档看不懂。呵呵。原来在抱怨方面也有递归啊。据说，敏捷开发可以降低程序开发中的文档，据说他们可以把代码写得跟文档和示图似的，不知道是真是假。不过，我听过太多太多的程序员抱怨没文档太少，文档太差了，这个方面要怪还是怪程序员自己。
第四位 部署环境
虽然，程序员们开发的是软件，但是我们并不知道我们的程序会被部署或安装在什么样的环境下，比如，网络上的不同，RAID上的不同，BIOS上的不同，操作系统的不同(WinXP和Win2003)，有没有杀毒软件，和其它程序是否兼容，系统中有流氓软件或病毒等等。当然，只要你的软件出现错误，无论是你的程序的问题，还是环境的问题，反正都是你的问题，你都得全部解决。所以，程序员们并不是简单地在编程，很多时候，还要当好一个不错的系统管理员。每当最后确认问题的原因是环境问题的时候，可能程序员都是会心生怨气。
第三位 问题报告
我的软件不工作了，程序出错了，每当我们听到这样的问题报告的时候，程序员总是感到很痛苦，因为这样的问题报告等于什么也没有说，但还要程序员去处理这种错误。没有明确的问题描述，没有说明如何重现问题，在感觉上，当然会显得有点被人质问的感觉，甚至，在某些时候还掺杂着看不起，训斥的语气，当然，程序员基本上都是很有个性的，都是软硬不吃的主儿。所以，每当有这样的语气报告问题的时候，他们一般也会把话给顶回去，当然，后面自己然发生一些不愉快的事情。所以，咱们还是需要一个客服部门来帮助我们的程序员和用户做好沟通。
第二位 程序员自己
惹毛程序员的可能还是程序员自己，程序员是相轻的，他们基本上都是恃才傲物的，总是觉得自己才是最牛的，在程序员间，他们几乎每天都要吵架，而且一吵就吵得脸红脖子粗。在他们之间，他们总是被自己惹毛。
技术上的不同见解。比如Linux和Win，VC++和VB，Vi和Emacus，Java和C++，PHP和Ruby等等，等等。什么都要吵。
老手对新手的轻视。总是有一些程序员看不起另一些程序员，说话间都带着一种傲慢和训斥。当新手去问问题的时候，老手们总是爱搭不理。
在技术上不给对方留面子。不知道为什么，程序员总是不给对方留面子，每当听到有人错误理解某个技术的时候，他们总是喜欢当众大声指证，用别人的错误来表明自己的博学，并证明他人的无知。
喜好鄙视。他们喜好鄙视，其实，这个世界上没有一件事是完美的，有好就有不好，要挑毛病太容易了。程序员们特别喜欢鄙视别人，无论是什么的东西，他们总是喜欢看人短而不看人长。经常挂在他们嘴上的口头禅是太差、不行等等。
程序员，长期和电脑打交道，编写出的代码电脑总是认真的运行，长期养成了程序员们目空一切的性格，却不知，这个世界上很多东西并不是能像电脑一样，只要我们输入正确的指令它就正确地运行这么简单。程序员，什么时候才能变得成熟起来
第一位 程序员的代码
无论你当时觉得自己的设计和写的代码如何的漂亮和经典，过上一段时间后，再回头看看，你必然会觉得自己的愚蠢。当然，当你需要去维护他人的代码的时候，你一定要在一边维护中一边臭骂别人的代码。是否你还记得当初怎么怎么牛气地和别人讨论自己的设计和自己的代码如何如何完美的?可是，用不了两年，一刚从学校毕业的学生在维护你的代码的过程当中就可以对你的代码指指点点，让你的颜面完全扫地。
呵呵。当然，也有的人始终觉得自己的设计和代码就是最好的，不过这是用一种比较静止的眼光来看问题。编程这个世界变化总是很快的的，很多事情，只有当我们做过，我们才熟悉他，熟悉了后才知道什么是更好的方法，这是循序渐进的。所以，当你对事情越来越熟悉的时候，再回头看自己以前做的设计和代码的时候，必然会觉得自己的肤浅和愚蠢，当然看别人的设计和代码时，可能也会开始骂人了。
1、猫在练习长跑，乌龟讽刺道：再练，也不能跑出个长跑冠军！猫答：我成不了豹子，却能做最棒的猫！是的，努力做好自己，做到最棒，就是成功！
2、一万元以内的奢侈品，可以买，但不可以炫耀。
3、别人可以拷贝我的模式，不能拷贝我的苦难，不能拷贝我不断往前的激情。
4、就算月挣3000，房租（贷）2000，但该请客的时候也决不含糊。
5、买个闹钟，以便按时叫醒你：
自贪睡和不守时，都将成为你工作和事业上的绊脚石，任何时候都一样。不仅要学会准时，更要学会提前。就如你坐车去某地，沿途的风景很美，你忍不住下车看一看，后来虽然你还是赶到了某地，却不是准时到达。“闹钟”只是一种简单的标志和提示，真正灵活、实用的时间，掌握在每个人的心中。
6、如果你不喜欢现在的工作，要么辞职不干，要么就闭嘴不言：
初出茅庐，往往眼高手低，心高气傲，大事做不了，小事不愿做。不要养成挑三拣四的习惯。不要雨天烦打伞，不带伞又怕淋雨，处处表现出不满的情绪。记住，不做则已，要做就要做好。
7、权威是你把权给别人的时候，你才能有真正的权利，你懂得倾听、懂得尊重，承担责任的时候，别人一定会听你，你才会有权威。
8、一个成功的创业者，三个因素，眼光、胸怀和实力。
9、机会从不会“失掉”，你失掉了，自有别人会得到：
不要凡事在天，守株待兔，更不要寄希望于“机会”。机会只不过是相对于充分准备而又善于创造机会的人而言的。也许，你正为失去一个机会而懊悔、埋怨的时候，机会正被你对面那个同样的“倒霉鬼”给抓住了。没有机会，就要创造机会，有了机会，就要巧妙地抓住。
10、若电话老是不响，你该打出去：
很多时候，电话会给你带来意想不到的收获，它不是花瓶，仅仅成为一种摆设。交了新朋友，别忘了老朋友，朋友多了路好走。交际的一大诀窍就是主动。好的人缘好的口碑，往往助你的事业更上一个台阶。
11、永远把别人对你的批评记在心里，别人的表扬，就把它忘了。
12、有时候心理因素可能比外界的因素有更大的影响，所以一个人的心态非常重要。很多人总是很不满足，说我为什么不如那个人好，我为什么挣的钱不如那个人多，这样的心态可能会导致自己越来越浮躁，也不会让自己觉得幸福。
13、神要是公然去跟人作对，那是任何人都难以对付的。
14、善良人在追求中纵然迷惘，却终将意识到有一条正途。
15、认识自己的无知是认识世界的最可靠的方法。
16、不想当将军的士兵不是好士兵，但是一个当不好士兵的将军一定不是好将军。
17、如果冬天来了，春天还会远吗
18、哪里烧书，哪里接着就会把人也扔进火堆。
19、黑夜给了我黑色的眼睛，我却用它寻找光明。
20、赚钱模式越多越说明你没有模式。
21、永远要相信边上的人比你聪明。
22、上当不是别人太狡猾，而是自己太贪，是因为自己才会上当。
23、一个一流的创意，三流的执行，我宁可喜欢一个一流的执行，三流的创意。
24、最优秀的模式往往是最简单的东西。
25、要少开店、开好店，店不在于多，而在于精。
26、创业者书读得不多没关系，就怕不在社会上读书。
27、很多人失败的原因不是钱太少，而是钱太多。
28、创业者光有激情和创新是不够的，它需要很好的体系、制度、团队以及良好的盈利模式。
29、不要贪多，做精做透很重要，碰到一个强大的对手或者榜样的时候，你应该做的不是去挑战它，而是去弥补它。
30、这世界上没有优秀的理念，只有脚踏实地的结果。
31、如果你看了很多书，千万别告诉别人，告诉别人别人就会不断考你。
32、小企业有大的胸怀，大企业要讲细节的东西。
33、所有的创业者应该多花点时间，去学习别人是怎么失败的。
34、关注对手是战略中很重要的一部分，但这并不意味着你会赢。
35、不管你拥有多少资源，永远把对手想得强大一点。
36、80年代的人不要跟70年代、60年代的人竞争，而是要跟未来，跟90年代的人竞争，这样你才有赢的可能性。
37、必须先去了解市场和客户的需求，然后再去找相关的技术解决方案，这样成功的可能性才会更大。
38、最核心的问题是根据市场去制定你的产品，关键是要倾听客户的声音。
39、世界上最宝贵的财富就是时间，所以不要浪费一分一秒！
40、免费是世界上最昂贵的东西。所以尽量不要免费。等你有了钱以后再考虑免费。
41、诚信绝对不是一种销售，更不是一种高深空洞的理念，它是实实在在的言出必行、点点滴滴的细节。
42、短暂的激情是不值钱的，只有持久的激情才是赚钱的。
43、我自己不愿意聘用一个经常在竞争者之间跳跃的人。
44、多花点时间在你的其他员工身上。
45、什么是团队呢?团队就是不要让团队的任何一个人失败。
46、创业时期千万不要找明星团队，千万不要找已经成功过的人，创业要找最适合的人，不要找最好的人。
47、最大的挑战和突破在于用人，而用人最大的突破在于信任人。
48、碰到灾难第一个想到的是你的客户，第二想到你的员工，其他才是想对手。
49、永远记住每次成功都可能导致你的失败，每次失败好好接受教训，也许就会走向成功。
50、可能一个人说你不服气，两个人说你不服气，很多人在说的时候，你要反省，一定是自己出了一些问题。
51、从创业得第一天起，你每天要面对的是困难和失败，而不是成功。我最困难的时候还没有到，但有一天一定会到。困难不是不能躲避，不能让别人替你去抗。九年创业的经验告诉我，任何困难都必须你自己去面对。创业者就是面对困难。
52、我认为，员工第一，客户第二。没有他们，就没有阿里巴巴。也只有他们开心了，我们的客户才会开心。而客户们那些鼓励的言语，鼓励的话，又会让他们像发疯一样去工作，这也使得我们的网站不断地发展。”
53、不要在乎别人如何看你,要在乎你自己如何看未来,看梦想,看世界..!
54、一个年轻人，如果三年的时间里，没有任何想法，他这一生，就基本这个样子，没有多大改变了。
55、与人交往的时候，多听少说。这就是，上帝为什么给我们一个嘴巴两个耳朵的原因。
56、不要随便说脏话，这会让别人觉得你没涵养，不大愿意和你交往。即使交往，也是敷衍，因为他内心认定你素质很差。
57、要想进步，就只有吸取教训，成功的经验都是歪曲的，成功了，想怎么说都可以，失败者没有发言权，可是，你可以通过他的事例反思，总结。教训，不仅要从自己身上吸取，还要从别人身上吸取。
58、大学毕业了，不是学习结束了，而是刚刚开始了！
59、记住，平均每天看电视超过三个小时以上的，平均每天玩网络游戏或聊天超过三个小时以上的，一定都是那些月收入不超过三千元的，如果你想要月收入超过三千，请不要把时间浪费在电视和虚幻的网络上。
60、平时多和你的朋友沟通交流一下，不要等到需要朋友的帮助时，才想到要和他们联系，到了社会，你才会知道，能够认识一个真正的朋友，有多难?
61、如果你想知道自己将来的年收入如何。找你最经常来往的六个朋友，把他们的年收入加起来，除以六，就差不多是你的了。
62、关于爱情，有这么一句话，没有面包，怎么跳舞？无论什么时候，你决定去好好爱一个人的时候，一定要考虑给她你能给予的最好的物质生活。
63、给自己定一个五年的目标，然后，把它分解成一年一年，半年半年的，三个月的，一个月的。这样，你才能找到自己的目标和方向。
64、这个世界上没有免费的午餐，永远不要走捷径！
65、这个世界上有很多天才，天才是用来欣赏的，不是用来攀比的。
66、要每天多努力一些，比别人多努力一个小时。
67、女人的温柔和男人的成就是成正比的。
68、那些私下忠告我们，指出我们错误的人，才是真正的朋友。
69、我们公司是每半年一次评估，评下来，虽然你的工作很努力，也很出色，但你就是最后一个，非常对不起，你就得离开。
70、一个好的企业靠输血是活不久的，关键是要自己去造血。
71、有干劲，你就洒下汗水；有知识，你就献出智慧；二者都不具备，请你让出岗位。
72、好心态才有好状态。
73、从无到有，是件快乐的事。而从有到无，同样是种快感。
74、看别人不顺眼，首先是自己修养不够。
75、从最不满意的客户身上，学到的东西最多。
76、有志不在年高，无志空活百岁。
77、一个人快乐不是因为他拥有得多，而是因为计较得少。
78、听不到奉承的人是一种幸运，听不到批评的人却是一种危险。
79、世界上还有很多事情，只要你把它做透了，做成专家，你就能够为自己创造成功的机会。
80、团队核心成员有人要提出辞职时，不要挽留，既然提出了，他迟早是要走的。
81、初中水平跟博士后没啥区别。只要能干就行，我一直是这个观点，不在乎学历，只要能干能做出贡献就行。
82、所谓人才，就是你交给他一件事情，他做成了；你再交给他一件事情，他又做成了。
83、生活是不公平的，要去适应它。
84、生活中你没有暑假可以休息，也无人帮你发现自我
85、天赋就是兴趣 兴趣就是天赋
86、挫折不是惩罚 而是学习的机会
87、在学习上不肯钻研的人是不会提出问题的；在事业上缺乏突破力的人是不会有所创新的。
88、自学如果缺乏恒心，专业知识就无法得到巩固。
89、时间，就象海棉里的水，只要愿挤，总还是有的。
90、书读得越多而不加思索，你就会觉得你知道得很多；而当你读书而思考得越多的时候，你就会越清楚地看到，你知道得还很少。
91、如果顾客不喜欢，那该产品就是有缺陷。
92、当许多人在一条路上徘徊不前时，他们不得不让开一条大路，让那珍惜时间的人赶到他们的前面去。
93、从不浪费时间的人，没有工夫抱怨时间不够。
94、合理安排时间，就等于节约时间。
95、聪明出于勤奋，天才在于积累。
96、如果你做某件事，那就把它做好；如果你不会或不愿做好它，那最好不要去做。
97、学习这件事，不在乎有没有人教你，最重要的是在于你自己有没有觉悟和恒心。
98、一个人的工作职位不怕低，只要你不放弃你的理想，拿目前的工作做一个踏脚石，一方面维持生活，一方面找时间充实自己，认准一个确定的方向去努力。慢慢的，你总会发现，你的努力没有白费。
99、没有任何动物比蚂蚁更勤奋，然而它却最沉默寡言。
100、千里之堤毁于蚁穴。
子线程先循环10次，然后主线程循环100次，再子线程循环10次，主线程循环100次，就这样循环往复50次。
public class Communtion01 {
public static void main(String args[]) {
final Bussiness buss = new Bussiness();
new Thread(new Runnable() {
public void run() {
for (int j = 1; j <= 50; j++) {
buss.sub(j);
}
}
}).start();
for (int j = 1; j <= 50; j++) {
buss.main(j);
}
}
}
class Bussiness {
private boolean subFlag = true;
//Cpu照顾sub线程，执行到sub()，但还不该sub执行，那就wait
public synchronized void sub(int j) {
while (!subFlag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + "在第" + j
+ "次循环了" + i);
}
subFlag = false;
this.notify();
}
public synchronized void main(int j) {
while(subFlag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i =1; i <=100; i++) {
System.out.println(Thread.currentThread().getName() + "在第" + j
+ "次循环了" + i);
}
subFlag = true;
this.notify();
}
}
经验：要用到共同数据（包括同步锁）或共同算法的若干方法应该归在同一个类身上，这种设计体现了高类聚和程序的健壮性。
互斥、同步、通信问题的逻辑不是写在线程代码上，而是在线程访问那个资源类上。
第一个示例更多的是运用了内部类的特性：
内部类重要特点：可以访问外部的成员变量，所以内部类不能在静态方法中实例化。
因为静态方法运行时不需要创建实例对象，而内部类想要访问成员变量，意味着外部类肯定要创建实例对象，二者相互矛盾。
所以下面就会报错
public class Synchronized01 {
public static void main(String args[]) {
）
// final Outputer outputer=new Outputer(); //这样做就没有成员变量可以访问
// new Thread(new Runnable(){
//
// public void run() {
// while(true){
// try {
// Thread.sleep(10);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// outputer.outputer("zhangsan");
// }
// }}).start();
}
class Outputer {
void outputer(String name) {
int len = name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
但如果改成这样就没有问题
public class Synchronized01 {
public static void main(String args[]) {
new Synchronized01().init();
}
// 此方法被调用时一定创建了外部类对象
private void init() {
// 运行时找外部类对象，找调用init方法的对象
final Outputer outputer = new Outputer();
new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer("zhangsan");
}
}
}).start();
new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer("lisi");
}
}
}).start();
}
class Outputer {
void outputer(String name) {
int len = name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
运行结果
lisi zhangsan lisi zhangsan lisi zhangsan lisi zhangsan lisi zhangsan
lisi zhangsan lisi zhangsan lisi zhanlgissain
zlhiasnig san lzihsain gsan zlhiasnig san zlhiasnig san zlhiasnig san
zlhiasnigsan zlhiasnig san lzihsain gsan lisi zhangsan lisi
解决方法
修改Ouputer
class Outputer {
public void outputer(String name) {
int len = name.length();
synchronized (this) {// 两个线程用的是同一个outputer对象
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
// synchronized要在void之前
// 一个方法只能有一个synchronized，不然可能会造成死锁
public synchronized void outputer2(String name) {
int len = name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
// class Outputer {
// String xxx = "";
//
// public void outputer(String name) {
// int len = name.length();
// xxx必须是同一个对象，如果是name就仍然会出错 name是两个对象
// synchronized (xxx) {
// for (int i = 0; i < len; i++) {
// System.out.print(name.charAt(i));
// }
// System.out.println();
// }
// }
//
// }
但如果每个run()中这样写new Outputer()然后调用outputer(name)仍然会出错，因为每次new都是产生一个新的对象，而synchronized关键是针对同一个对象。
public class Synchronized02 {
public static void main(String[] args) {
new Synchronized02().init();
}
private void init() {
final Outputer outputer = new Outputer();
new Thread(new Runnable() {
public void run() { // 要执行的操作
while (true) { // 循环操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer("zhangsan");
}
}
}).start();
new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer("lisi");
//这样仍然会出问题 ----不是同一个对象。
// new Outputer().outputer("lisi"); }
}
}).start();
}
class Outputer {
public void outputer(String name) {
int len = name.length();
synchronized (this) {// 两个线程用的是同一个outputer对象
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
// synchronized要在void之前
// 一个方法只能有一个synchronized，不然可能会造成死锁
public synchronized void outputer2(String name) {
int len = name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
// class Outputer {
// String xxx = "";
//
// public void outputer(String name) {
// int len = name.length();
// xxx必须是同一个对象，如果是name就仍然会出错 name是两个对象
// synchronized (xxx) {
// for (int i = 0; i < len; i++) {
// System.out.print(name.charAt(i));
// }
// System.out.println();
// }
// }
//
// }
}
一个内部类前面加上static就变成了外部类
静态方法只能在外部类中声明
静态方法只和字节码对象有关
public class Synchronized03 {
public static void main(String[] args) {
new Synchronized03().init();
}
private void init() {
final Outputer outputer = new Outputer();
new Thread(new Runnable() {
public void run() { // 要执行的操作
while (true) { // 循环操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer("zhangsan");
}
}
}).start();
new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.outputer2("lisi");
}
}
}).start();
}
static class Outputer { // 加上static 相当于是个外部类
public void outputer(String name) {
int len = name.length();
// 静态方法不创建类的实例对象，创建字节码对象,静态方法运行时只和字节码对象关联
synchronized (Outputer.class) {
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
// synchronized要在void之前
// 静态方法只能在外部类中声明
public static synchronized void outputer2(String name) {
int len = name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
在T公司工作快一年了，刚进入公司就参与到项目的开发中，开发小组加上我一共5个人。公司下达的任务是在一个月的时间必须完成这个项目，接下来进行的就是很多软件公司常用方式：加班，没日没夜的加班。所以我刚进入公司的一个月是在加班中度过的。加班的好处有很多，比如：提升了技术，更快地融入了团队，但也有坏处，特别是对刚进入公司的我，最后由于高强度的加班，再加上公司垃圾的工作环境，最后造成了颈椎出了问题。
之所以选择这家公司，是因为在学校时听说这家公司很不错（很久以前确实很牛），但进入公司后发现不是那么回事，至少我所在的组是这样的。
坦白的说我不喜欢甚至讨厌第一个项目经理S，S向下对组内成员从没有关心过，每当项目快完成时就说“做完了这个项目拉上测试组我们举行一次聚餐”，但直到S最后离开公司的那天他才举行了一次他花费了200多块钱请了10多个人的餐会。很少见S在技术上帮助组内成员，就算是进行一些指导也不是技术人员该有的交流沟通，而是当作一种恩赐赏给下属。项目完成后不能看到别人没活干，比如浏览ITeye、学一些自己感兴趣的技术，看到你没活干立马给你分配任务，不让你有喘息的机会。
组中两个有差不多两年开发经验，其中一个带我的A，另一个负责一个项目维护的B。项目经理常常和B争吵，和项目经理相比B的经验各方面肯定不如项目经理，所以每当B关于项目提出一些自己的观点，垃圾项目经理就会把B批的体无完肤，而且经常是抓住一些无关紧要的问题批评，其他组人员看到就想楱我们项目经理（包括我）。向上不知道项目经理怎么和领导沟通，但通过项目的数量、进度就可以得知项目经理不会和领导沟通，而且没有地位。这在我们分到另一个组，通过另一个项目经理的交流得到了证实。
总之，我非常讨厌前任项目经理，不是因为他对我做了什么，而是对我们身边的开发人员所作所为非常不满。所以当他宣布他要离开这家公司时，我悲伤的脸上掩饰不住兴奋的表情。
第一个项目经理走后我们组就被另一个项目经理Y接管（Y被认为是公司的一个传奇人物），一到另一个组就获得了自由的感觉：只要分配给你的任务完成，你就可以研究你喜欢的技术了，而且每周都会举行一次聚餐来加强组内成员的沟通、交流。在Y带领下参与了另一个项目开发，虽然在这个组也是很累，因为毕竟还在这个公司，但已经没有了前任项目经理S那时的阴影，所以整体感觉还是很不错的。通过和Y交流得知领导分配给他任务时不是一味的讨好领导（至少不委曲求全），而是也接这个项目，但时间必须延长，不然不做。这样Y管辖项目通常时间充足，开发人员也不是很累，最后也完成了任务。而S，不管领导分配什么项目就接（估计和他根本没什么拿得出手的项目有关），从不考虑组内成员的承受能力，最后结果可想而知。
很遗憾的是，当前任项目经理S离职不久，公司就进入了离职“热潮”，公司里有经验的开发人员几乎都走了，因为公司太吝啬，不肯出高价挽留人才，所以这股“离职风”一直持续了半年，最后我们组也不能幸免。组内有经验的开发人员都走了，包括A、B。直到一个研究生学历的开发人员W也走了，Y坐不住了，我也坐不住了。Y坐不住是因为他现在负责的DS这块已经不是公司的主营业务，再加上手下的一个个得力干将都出去找到比他还牛的工作，也被逼无奈离开了。我坐不住是公司的业务方向我不感兴趣而且学不到想要的技术，做政府业务靠的不是技术，而是人脉。开发人员水平的高低对公司业绩影响很小，所以公司不注重开发人员技术能力提高。虽然技术只是工具，最重要的是开发思想，业务能力，但目前我最需要的或许还是技术。
回顾这一年感概良多，由于自己的心理不够成熟、处事能力不行，再加上个人性格、修养的问题错过了好多好多机会。
我的缺点是：
1. 爱抱怨---在一次封闭开发中体现的淋漓尽致
2. 对他人要求严格----因为我常常有这样一种想法：我能做到的其他人一样能做到，但当有人做不到时就发挥了1的缺点
3. 态度不诚恳----别人遇到问题需要我解答时，我内心也十分乐意解答，但语气、神态各方面让人感到很不爽（我在给别的开发人员指导时被W发现了，虽然没有明说，但我也感觉到了不妥）
4. 太浮躁、沉不下去
5 平时说话大大咧咧，以后需要去掉这个坏毛病
6. 不会和领导沟通，沟通时总感觉不爽，没有将自己想要说的说出来。
7. 技术还亟需提高
其实总结以上缺点明显最多的还是自身修养问题，要想在以后的职场中有优秀的表现，自身修养还是非常注意的。
入门
public class Time01 {
public static void main(String[] args) {
// Timer timer01=new Timer();
// timer01.schedule(new TimerTask(){
//
// @Override
// public void run() {
//
// System.out.println("bombing");
// }}, 1000);
new Timer().schedule(new TimerTask() {
@Override
public void run() {
System.out.println("bombing");
}
}, 10000);
while (true) {
System.out.println(new Date().getSeconds());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果
21
22
23
24
25
26
27
28
29
30
bombing
31
32
33
连续执行
public class Time02 {
public static void main(String[] args) {
new Timer().schedule(new TimerTask() {
@Override
public void run() {
System.out.println("bombing");
}
}, 10000,3000); //每隔3秒执行
while (true) {
System.out.println(new Date().getSeconds());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果：
50
51
52
53
54
55
56
57
58
59
bombing
0
1
2
bombing
3
4
5
bombing
6
7
提高
匿名内部类是临时的
整数分为奇数和偶数，所以可以按照奇偶操作完成
/**
*一个2秒执行，另一个4秒执行，交替循环往复
*
*/
public class Time03 {
static int i = 0; // 静态变量可以记录类创建的对象数量
public static void main(String[] args) {
class MyTimerTask extends TimerTask {
//内部类内部不能生成静态变量
public void run() {
i=(i+1)%2;
System.out.println("bombing");
new Timer().schedule(new MyTimerTask(), 2000+2000*i);
}
}
new Timer().schedule(new MyTimerTask(), 2000);
while (true) {
try {
System.out.println(new Date().getSeconds());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果：
13
14
bombing
15
16
17
18
bombing
19
20
bombing
21
22
23
24
bombing
25
/**
* 每天在指定的时间执行操作
* 提供调度需求的开源框架Quartz在这方面处理能力很强
*/
public class Timer04 {
public static void main(String[] args) {
String str = "2011-08-28 08:39:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Timer timer = new Timer();
try {
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("timer");
}
}, sdf.parse(str), 24 * 60 * 1000);
} catch (ParseException e) {
e.printStackTrace();
}
while (true) {
System.out.println(new Date().getSeconds());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
* 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 timer 0 1 2 3 4 5
*/
}
1.进程与线程
每个进程都独享一块内存空间，一个应用程序可以同时启动多个进程。比如IE浏览器，打开一个Ie浏览器就相当于启动了一个进程。
线程指进程中的一个执行流程，一个进程可以包含多个线程。
每个进程都需要操作系统为其分配独立的内存空间，而同一个进程中的多个线程共享这块空间，即共享内存等资源。
每次调用java.exe的时候，操作系统都会启动一个Java虚拟机进程，当启动Java虚拟机进程时候，Java虚拟机都会创建一个主线程，该线程会从程序入口main方法开始执行。
Java虚拟机每启动一个线程，就给会给该线程分配一个线程方法栈，用来存放相关信息（比如局部变量等），线程就在这个栈上运行。所以Java对象中的局部变量都是线程安全的，但实例变量及类变量由于不是保存在栈中，所以不是线程安全的。
进程有三种状态：就绪、执行、阻塞。
2.线程创建方式
Runnable方式：（此种方式灵活，推荐使用）
public class Thread02 implements Runnable {
public static void main(String[] args) {
Runnable r = new Thread02();
Thread t1 = new Thread(r, "t1");
/**
* Thread源码
* public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
*/
Thread t2 = new Thread(r, "t2");
t1.start(); // 启动线程t1，处于就绪状态，等待cpu
t2.start(); // 启动线程t2，处于就绪状态，等待cpu
t1.run(); // 主线程main调用对象t1的run方法
}
public void run() {
System.out.println("thread's name is "
+ Thread.currentThread().getName());
}
}
运行结果可能是：
thread's name is t1
thread's name is main
thread's name is t2
Thead方式
public class Thread03 extends Thread {
public static void main(String[] args) {
Thread03 t1 = new Thread03(); //不注意的情况下写成了Thread t1=new Thread() 注：Thread03此时就是一个线程了
t1.start();
}
public void run() {
System.out.println("thread's name is "
+ Thread.currentThread().getName());
}
}
运行结果：thread's name is Thread-0
注意：每次程序运行时除了自定义的线程外还有一个main线程。
综合：
public class Thread01 {
public static void main(String[] args) {
Thread thread=new Thread();
thread.start();//真正起作用 的是run()
/**而Thread中的run
* public void run() {
if (target != null) {
target.run();
}
}
所以自己创建的线程要重写run方法，把要执行的内容放到run()中，所以要实现接口或继承进而产生子类
*/
//创建线程的方式1 thread子类方式（继承）
Thread thread1=new Thread(){
public void run() {
while(true){
try {
Thread.sleep(500);//休息500毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//Thread.currentThread()得到当前线程
System.out.println("线程1的名字是 "+Thread.currentThread().getName());
}
}
};
// thread1.start(); //不写 线程无法启动
//创建线程的方式2 runnable方式（实现） 推荐使用
Thread thread2=new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2'name is "+Thread.currentThread().getName());
}
}});
// thread2.start();
//执行的是thread
new Thread(new Runnable(){
public void run() {
System.out.println("runnable "+Thread.currentThread().getName());
}}){
public void run() { //子类中的run方法覆盖父类中的run方法，这样就不会执行runnable
System.out.println("thread "+Thread.currentThread().getName());
}
}.start();
}
/***
* 在单个cpu中执行多线程很有可能降低执行效率而不是提高 一个人在不同地方做同一件事情
*/
}
文章出自：http://blog.sina.com.cn/s/blog_66c069db0100yevq.html
经常在一些技术论坛里看到，有人抱怨说做开发好多年了，技术没有多大长进，薪水也没有提升；
经常会碰到一些做技术外包的同学，说我天天coding，coding，今天换这个东家、明天换那个东家，代码也写了几十万行，但几年下来，个人竞争力却没多大提升； 也时常听到一些在大公司里工作的开发人员抱怨，虽然拿着不错的薪水，在公司里成天就像一个螺丝钉一样，被安排在一个细小的领域里，几年下来，抠来抠去，就那点东西，实在微不足道，同行面前拿不出手，没有成就感； 不一一列举，相信做IT技术的人，多少都会碰到上面所说的情况，因此，对于做IT技术的人，如何提升自身的竞争力，或者说的再俗一点，如何能保持、提升自身的身价，做一棵职场的常青藤，需要认真思考一下。
最近我搜集了一下互联网各大公司的招聘广告、也观察了一下公司里的一些技术高手的一些成长特点、结合自己的既往的一些工作经历，有了一个初步的思考，虽然说不上是找到了一条捷径，但是在现阶段的认识来看，我认为这是技术成长的一条通路，在团队内部做了一个分享，希望能引起大家的思考：
关于开发工程师成长的问题最近有一些思考，做个分享，先抛两个观点：
1、 夯实技术基础应以企业（市场）本质需求为导向，技术人员的身价或者核心竞争力的体现最终是由企业（市场）的本质需求决定的，这个本质需求是能用最快的速度提供可靠的综合解决方案，而不是看谁的技术玩得更酷或者更新潮；
2、 技术人员对技术的把控程度，很大程度决定了一个技术人员的“身价”和“话语权”，在当前千军万马的互联网技术大军里：
（1）懂得某种技术的 “HowTo”的一抓一大把，属于金字塔的底层
（2）能再往前进一步，深入理解这门技术“Why”的，相对来说就要少一点了，属于金字塔的第二层
（3）能对一门技术理解了以后，能对既有技术进行优化和改进的，就更少了，属于金字塔的第三层
（4）那金字塔的第四层是什么类型的人呢？我给出的定义是那些对多种技术有深入的理解，在提供综合解决方案时，面对多种技术知道如何取舍和搭配的人、能对已形成的搭配方案进行优化和改进的人，这种人是企业里的“香饽饽”，形象说明如下：
所以，要提高自身的核心竞争力、提高身价，第一个首先要想清楚发力点在哪里、成长路径是什么，对于上图描述，大家思考和观察一下，是不是这么个道理？
第二个要谈的，是作为一名互联网开发工程师，要掌握哪些必备的关键技术；下面罗列出来的这些技术，是最近我去分析了一下各个公司对开发成员的招聘要求、观察淘宝一些高P所具备的知识，包括自己之前做开发工程师的一些体会，总结了一下做互联网开发，一些通用的、开发工作中经常接触的的技术列表出来，这些必备技术要尽量确保每一项技术掌握到上图中金字塔的二、三层发展，不能老处在第一层，这样没有竞争力，“了解”和“熟悉”这两个概念差距还是蛮大的：
WebServer：
1、 Apache(nginx)
2、 Tomcat
3、 Jboss
前端技术：
1、 html/css/js
2、 ajax
3、 前端框架：protype、dwr、Jquery、JfreeChart、ExtJs
Java技术：
1、 Java语言；
2、 JVM 虚拟机
3、 J2EE技术
数据库相关技术：
1、 关系型数据库：Mysql、Oracle
2、 NoSql：Cassandra、MonGoDB
工具：
1、 IDE：Eclipse
2、 编译打包：Maven（Ant）
3、 单元测试：Junit
4、 代码管理：SVN(Cvs)
5、 前端调试：Httpwatch、Firebug
6、 压力测试：ab
开发框架：
1、 MVC框架: Struts2、Webwork、Webx、Spring
2、 ORMapping框架: Ibatis、Hibernate
集群及缓存技术：
1、 DNS
2、 LVS+Keepalived
3、 Squid、MemCached
系统及网络基础：
1、 Linux系统；
2、 监控；
3、 TCP/IP协议、HTTP协议;
“板凳做得十年冷”，做技术需要耐得住寂寞，量变到质变，融会贯通，需要有一个过程，技术基础也是一步步夯实起来的，这是个客观规律，但是即使要坐“十年板凳”的时候，还是要规划一下该学什么、怎么学、一步步去完善，否则会发现十年下来，板凳坐冷了，心也冷了，那就很悲剧；