#
基本的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協議;
“板凳做得十年冷”，做技術需要耐得住寂寞，量變到質變，融會貫通，需要有一個過程，技術基礎也是一步步夯實起來的，這是個客觀規律，但是即使要坐“十年板凳”的時候，還是要規劃一下該學什么、怎么學、一步步去完善，否則會發現十年下來，板凳坐冷了，心也冷了，那就很悲劇；