勞特巴赫編譯器關閉代碼優化
① 如何優化java代碼及提高執行效率
可供程序利用的資源（內存、CPU時間、網路帶寬等）是有限的，優化的目的就是讓程序用盡可能少的資源完成預定的任務。優化通常包含兩方面的內容：減小代碼的體積，提高代碼的運行效率。本文討論的主要是如何提高代碼的效率。
在Java程序中，性能問題的大部分原因並不在於Java語言，而是在於程序本身。養成好的代碼編寫習慣非常重要，比如正確地、巧妙地運用java.lang.String類和java.util.Vector類，它能夠顯著地提高程序的性能。下面我們就來具體地分析一下這方面的問題。
1、 盡量指定類的final修飾符帶有final修飾符的類是不可派生的。在Java核心API中，有許多應用final的例子，例如java.lang.String。為String類指定final防止了人們覆蓋length()方法。另外，如果指定一個類為final，則該類所有的方法都是final。Java編譯器會尋找機會內聯（inline）所有的final方法（這和具體的編譯器實現有關）。此舉能夠使性能平均提高50%
。
2、 盡量重用對象。特別是String 對象的使用中，出現字元串連接情況時應用StringBuffer 代替。由於系統不僅要花時間生成對象，以後可能還需花時間對這些對象進行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。
3、 盡量使用局部變數，調用方法時傳遞的參數以及在調用中創建的臨時變數都保存在棧（Stack）中，速度較快。其他變數，如靜態變數、實例變數等，都在堆（Heap）中創建，速度較慢。另外，依賴於具體的編譯器/JVM，局部變數還可能得到進一步優化。請參見《盡可能使用堆棧變數》。
4、 不要重復初始化變數 默認情況下，調用類的構造函數時，
Java會把變數初始化成確定的值：所有的對象被設置成null，整數變數（byte、short、int、long）設置成0，float和double變數設置成0.0，邏輯值設置成false。當一個類從另一個類派生時，這一點尤其應該注意，因為用new關鍵詞創建一個對象時，構造函數鏈中的所有構造函數都會被自動調用。
5、 在JAVA + ORACLE 的應用系統開發中，java中內嵌的SQL語句盡量使用大寫的形式，以減輕ORACLE解析器的解析負擔。
6、 Java 編程過程中，進行資料庫連接、I/O流操作時務必小心，在使用完畢後，即使關閉以釋放資源。因為對這些大對象的操作會造成系統大的開銷，稍有不慎，會導致嚴重的後果。
7、 由於JVM的有其自身的GC機制，不需要程序開發者的過多考慮，從一定程度上減輕了開發者負擔，但同時也遺漏了隱患，過分的創建對象會消耗系統的大量內存，嚴重時會導致內存泄露，因此，保證過期對象的及時回收具有重要意義。JVM回收垃圾的條件是：對象不在被引用；然而，JVM的GC並非十分的機智，即使對象滿足了垃圾回收的條件也不一定會被立即回收。所以，建議我們在對象使用完畢，應手動置成null。
8、 在使用同步機制時，應盡量使用方法同步代替代碼塊同步。
9、 盡量減少對變數的重復計算
例如：for(int i = 0;i < list.size; i ++) {
…
}
應替換為：
for(int i = 0,int len = list.size();i < len; i ++) {
…
}
10、盡量採用lazy loading 的策略，即在需要的時候才開始創建。
例如： String str = 「aaa」;
if(i == 1) {
list.add(str);
}
應替換為：
if(i == 1) {
String str = 「aaa」;
list.add(str);
}
11、慎用異常
異常對性能不利。拋出異常首先要創建一個新的對象。Throwable介面的構造函數調用名為fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法檢查堆棧，收集調用跟蹤信息。只要有異常被拋出，VM就必須調整調用堆棧，因為在處理過程中創建了一個新的對象。異常只能用於錯誤處理，不應該用來控製程序流程。
12、不要在循環中使用：
Try {
} catch() {
}
應把其放置在最外層。
13、StringBuffer 的使用：
StringBuffer表示了可變的、可寫的字元串。
有三個構造方法 :
StringBuffer (); //默認分配16個字元的空間
StringBuffer (int size); //分配size個字元的空間
StringBuffer (String str); //分配16個字元+str.length()個字元空間
你可以通過StringBuffer的構造函數來設定它的初始化容量，這樣可以明顯地提升性能。這里提到的構造函數是StringBuffer(int
length)，length參數表示當前的StringBuffer能保持的字元數量。你也可以使用ensureCapacity(int
minimumcapacity)方法在StringBuffer對象創建之後設置它的容量。首先我們看看StringBuffer的預設行為，然後再找出一條更好的提升性能的途徑。
StringBuffer在內部維護一個字元數組，當你使用預設的構造函數來創建StringBuffer對象的時候，因為沒有設置初始化字元長度，StringBuffer的容量被初始化為16個字元，也就是說預設容量就是16個字元。當StringBuffer達到最大容量的時候，它會將自身容量增加到當前的2倍再加2，也就是（2*舊值+2）。如果你使用預設值，初始化之後接著往裡面追加字元，在你追加到第16個字元的時候它會將容量增加到34（2*16+2），當追加到34個字元的時候就會將容量增加到70（2*34+2）。無論何事只要StringBuffer到達它的最大容量它就不得不創建一個新的字元數組然後重新將舊字元和新字元都拷貝一遍――這也太昂貴了點。所以總是給StringBuffer設置一個合理的初始化容量值是錯不了的，這樣會帶來立竿見影的性能增益。
StringBuffer初始化過程的調整的作用由此可見一斑。所以，使用一個合適的容量值來初始化StringBuffer永遠都是一個最佳的建議。
14、合理的使用Java類 java.util.Vector。
簡單地說，一個Vector就是一個java.lang.Object實例的數組。Vector與數組相似，它的元素可以通過整數形式的索引訪問。但是，Vector類型的對象在創建之後，對象的大小能夠根據元素的增加或者刪除而擴展、縮小。請考慮下面這個向Vector加入元素的例子：
Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0;
I<100000; I++) { v.add(0,obj); }
除非有絕對充足的理由要求每次都把新元素插入到Vector的前面，否則上面的代碼對性能不利。在默認構造函數中，Vector的初始存儲能力是10個元素，如果新元素加入時存儲能力不足，則以後存儲能力每次加倍。Vector類就象StringBuffer類一樣，每次擴展存儲能力時，所有現有的元素都要復制到新的存儲空間之中。下面的代碼片段要比前面的例子快幾個數量級：
Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0; I<100000; I++) { v.add(obj); }
同樣的規則也適用於Vector類的remove()方法。由於Vector中各個元素之間不能含有「空隙」，刪除除最後一個元素之外的任意其他元素都導致被刪除元素之後的元素向前移動。也就是說，從Vector刪除最後一個元素要比刪除第一個元素「開銷」低好幾倍。
假設要從前面的Vector刪除所有元素，我們可以使用這種代碼：
for(int I=0; I<100000; I++)
{
v.remove(0);
}
但是，與下面的代碼相比，前面的代碼要慢幾個數量級：
for(int I=0; I<100000; I++)
{
v.remove(v.size()-1);
}
從Vector類型的對象v刪除所有元素的最好方法是：
v.removeAllElements();
假設Vector類型的對象v包含字元串「Hello」。考慮下面的代碼，它要從這個Vector中刪除「Hello」字元串：
String s = "Hello";
int i = v.indexOf(s);
if(I != -1) v.remove(s);
這些代碼看起來沒什麼錯誤，但它同樣對性能不利。在這段代碼中，indexOf()方法對v進行順序搜索尋找字元串「Hello」，remove(s)方法也要進行同樣的順序搜索。改進之後的版本是：
String s = "Hello";
int i = v.indexOf(s);
if(I != -1) v.remove(i);
這個版本中我們直接在remove()方法中給出待刪除元素的精確索引位置，從而避免了第二次搜索。一個更好的版本是：
String s = "Hello"; v.remove(s);
最後，我們再來看一個有關Vector類的代碼片段：
for(int I=0; I++;I < v.length)
如果v包含100,000個元素，這個代碼片段將調用v.size()方法100,000次。雖然size方法是一個簡單的方法，但它仍舊需要一次方法調用的開銷，至少JVM需要為它配置以及清除堆棧環境。在這里，for循環內部的代碼不會以任何方式修改Vector類型對象v的大小，因此上面的代碼最好改寫成下面這種形式：
int size = v.size(); for(int I=0; I++;I<size)
雖然這是一個簡單的改動，但它仍舊贏得了性能。畢竟，每一個CPU周期都是寶貴的。
15、當復制大量數據時，使用System.array()命令。
16、代碼重構：增強代碼的可讀性。
例如：
public class ShopCart {
private List carts ;
…
public void add (Object item) {
if(carts == null) {
carts = new ArrayList();
}
crts.add(item);
}
public void remove(Object item) {
if(carts. contains(item)) {
carts.remove(item);
}
}
public List getCarts() {
//返回只讀列表
return Collections.unmodifiableList(carts);
}
//不推薦這種方式
//this.getCarts().add(item);
}
17、不用new關鍵詞創建類的實例
用new關鍵詞創建類的實例時，構造函數鏈中的所有構造函數都會被自動調用。但如果一個對象實現了Cloneable介面，我們可以調用它的clone()方法。clone()方法不會調用任何類構造函數。
在使用設計模式（Design Pattern）的場合，如果用Factory模式創建對象，則改用clone()方法創建新的對象實例非常簡單。例如，下面是Factory模式的一個典型實現：
public static Credit getNewCredit() {
return new Credit();
}
改進後的代碼使用clone()方法，如下所示：
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}
上面的思路對於數組處理同樣很有用。
18、乘法和除法
考慮下面的代碼：
for (val = 0; val < 100000; val +=5) {
alterX = val * 8; myResult = val * 2;
}
用移位操作替代乘法操作可以極大地提高性能。下面是修改後的代碼：
for (val = 0; val < 100000; val += 5) {
alterX = val << 3; myResult = val << 1;
}
修改後的代碼不再做乘以8的操作，而是改用等價的左移3位操作，每左移1位相當於乘以2。相應地，右移1位操作相當於除以2。值得一提的是，雖然移位操作速度快，但可能使代碼比較難於理解，所以最好加上一些注釋。
19、在JSP頁面中關閉無用的會話。
一個常見的誤解是以為session在有客戶端訪問時就被創建，然而事實是直到某server端程序調用HttpServletRequest.getSession(true)這樣的語句時才被創建，注意如果JSP沒有顯示的使用 <%@pagesession="false"%> 關閉session，則JSP文件在編譯成Servlet時將會自動加上這樣一條語句HttpSession
session = HttpServletRequest.getSession(true);這也是JSP中隱含的session對象的來歷。由於session會消耗內存資源，因此，如果不打算使用session，應該在所有的JSP中關閉它。
對於那些無需跟蹤會話狀態的頁面，關閉自動創建的會話可以節省一些資源。使用如下page指令：<%@ page session="false"%>
20、JDBC與I/O
如果應用程序需要訪問一個規模很大的數據集，則應當考慮使用塊提取方式。默認情況下，JDBC每次提取32行數據。舉例來說，假設我們要遍歷一個5000行的記錄集，JDBC必須調用資料庫157次才能提取到全部數據。如果把塊大小改成512，則調用資料庫的次數將減少到10次。
[p][/p]21、Servlet與內存使用
許多開發者隨意地把大量信息保存到用戶會話之中。一些時候，保存在會話中的對象沒有及時地被垃圾回收機制回收。從性能上看，典型的症狀是用戶感到系統周期性地變慢，卻又不能把原因歸於任何一個具體的組件。如果監視JVM的堆空間，它的表現是內存佔用不正常地大起大落。
解決這類內存問題主要有二種辦法。第一種辦法是，在所有作用范圍為會話的Bean中實現HttpSessionBindingListener介面。這樣，只要實現valueUnbound()方法，就可以顯式地釋放Bean使用的資源。另外一種辦法就是盡快地把會話作廢。大多數應用伺服器都有設置會話作廢間隔時間的選項。另外，也可以用編程的方式調用會話的setMaxInactiveInterval()方法，該方法用來設定在作廢會話之前，Servlet容器允許的客戶請求的最大間隔時間，以秒計。
22、使用緩沖標記
一些應用伺服器加入了面向JSP的緩沖標記功能。例如，BEA的WebLogic Server從6.0版本開始支持這個功能，Open
Symphony工程也同樣支持這個功能。JSP緩沖標記既能夠緩沖頁面片斷，也能夠緩沖整個頁面。當JSP頁面執行時，如果目標片斷已經在緩沖之中，則生成該片斷的代碼就不用再執行。頁面級緩沖捕獲對指定URL的請求，並緩沖整個結果頁面。對於購物籃、目錄以及門戶網站的主頁來說，這個功能極其有用。對於這類應用，頁面級緩沖能夠保存頁面執行的結果，供後繼請求使用。
23、選擇合適的引用機制
在典型的JSP應用系統中，頁頭、頁腳部分往往被抽取出來，然後根據需要引入頁頭、頁腳。當前，在JSP頁面中引入外部資源的方法主要有兩種：include指令，以及include動作。
include指令：例如<%@ include file="right.html"
%>。該指令在編譯時引入指定的資源。在編譯之前，帶有include指令的頁面和指定的資源被合並成一個文件。被引用的外部資源在編譯時就確定，比運行時才確定資源更高效。
include動作：例如<jsp:include page="right.jsp"
/>。該動作引入指定頁面執行後生成的結果。由於它在運行時完成，因此對輸出結果的控制更加靈活。但時，只有當被引用的內容頻繁地改變時，或者在對主頁面的請求沒有出現之前，被引用的頁面無法確定時，使用include動作才合算。
24、及時清除不再需要的會話
為了清除不再活動的會話，許多應用伺服器都有默認的會話超時時間，一般為30分鍾。當應用伺服器需要保存更多會話時，如果內存容量不足，操作系統會把部分內存數據轉移到磁碟，應用伺服器也可能根據「最近最頻繁使用」（Most
Recently
Used）演算法把部分不活躍的會話轉儲到磁碟，甚至可能拋出「內存不足」異常。在大規模系統中，串列化會話的代價是很昂貴的。當會話不再需要時，應當及時調用HttpSession.invalidate()方法清除會話。HttpSession.invalidate()方法通常可以在應用的退出頁面調用。
25、不要將數組聲明為：public static final 。
26、HashMap的遍歷效率討論
經常遇到對HashMap中的key和value值對的遍歷操作，有如下兩種方法：Map<String, String[]> paraMap = new HashMap<String, String[]>();
................//第一個循環
Set<String> appFieldDefIds = paraMap.keySet();
for (String appFieldDefId : appFieldDefIds) {
String[] values = paraMap.get(appFieldDefId);
......
}
//第二個循環
for(Entry<String, String[]> entry : paraMap.entrySet()){
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
.......
}
第一種實現明顯的效率不如第二種實現。
分析如下 Set<String> appFieldDefIds = paraMap.keySet(); 是先從HashMap中取得keySet
代碼如下：
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
其實就是返回一個私有類KeySet, 它是從AbstractSet繼承而來，實現了Set介面。
再來看看for/in循環的語法
for(declaration : expression_r)
statement
在執行階段被翻譯成如下各式
for(Iterator<E> #i = (expression_r).iterator(); #i.hashNext();){
declaration = #i.next();
statement
}
因此在第一個for語句for (String appFieldDefId : appFieldDefIds) 中調用了HashMap.keySet().iterator() 而這個方法調用了newKeyIterator()
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
private class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
所以在for中還是調用了
在第二個循環for(Entry<String, String[]> entry : paraMap.entrySet())中使用的Iterator是如下的一個內部類
private class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
此時第一個循環得到key，第二個循環得到HashMap的Entry
效率就是從循環裡面體現出來的第二個循環此致可以直接取key和value值
而第一個循環還是得再利用HashMap的get(Object key)來取value值
現在看看HashMap的get(Object key)方法
public V get(Object key) {
Object k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length); //Entry[] table
Entry<K,V> e = table;
while (true) {
if (e == null)
return null;
if (e.hash == hash && eq(k, e.key))
return e.value;
e = e.next;
}
}
其實就是再次利用Hash值取出相應的Entry做比較得到結果，所以使用第一中循環相當於兩次進入HashMap的Entry中
而第二個循環取得Entry的值之後直接取key和value，效率比第一個循環高。其實按照Map的概念來看也應該是用第二個循環好一點，它本來就是key和value的值對，將key和value分開操作在這里不是個好選擇。
② 關閉編譯器內聯優化命令
方法如下：
1、可以通過設置編譯器選項虧昌禁止對strcpy、strcat等函數唯遲內聯，這樣就可以從匯編代碼來關閉。
2、在release版本可以選擇指空李在配置屬性點擊C+進行優化。
③ c語言防止優化
編譯器編譯命令里有設置選項，通過設置，你可以要求 不優化，也可以要求用哪種優化。
具體選項有哪些，要查自己編譯器的幫助文件。
例如，MS VC++ 6.0 編譯器編
優化選項：
/O1：優化使產生的可執行代碼最小
/O2：優化使產生的可執行代碼速度最快
/Oa：指示編譯器程序里沒有使用別名，可以提高程序的執行速度
/Ob：控制內聯（inline）函數的展開
/Od：禁止代碼優化
/Og：使用全局優化
/Oi：用內部函數去代替程序里的函數調用，可以使程序運行的更快，但程序的長度變長
/Op：提高浮點數比較運算的一致性
/Os：產生盡可能小的可執行代碼
/Ot：產生盡可能塊的可執行代碼
/Ow：指示編譯器在函數體內部沒有使用別名
/Ox：組合了幾個優化開關，達到盡可能多的優化
/Oy：阻止調用堆棧里創建幀指針
/O2 為了加速，會優化掉。 選 /Od 不優化。
④ 怎麼指定某段代碼不被編譯器優化掉
在C語言中， 某些語句，如：
int a；
a = 0；
a = 1；
a =2； 這個可能編譯器會把前面兩句給優惠掉， 這個如果 前面兩句也是必須要執行的， 可以把 int a 改成 volatile int a。
在編譯的時候， 編譯器可能會預測到某個變數的值， 就把中間的沒有必要的語句給優化掉，volatile 關鍵字就是告訴編譯器，不要做這樣的預測性優化， 按照文本代碼來翻譯。
⑤ ifort命令怎麼編譯mpi
1、icc
Intel C/C++編譯器接受遵守ANSI C/C++ , ISO C/C++ standards,GNU inline ASM for IA-32 architecture標準的輸入。與linux下常用的gcc兼容並支持更大的C語言擴展，包括源文件、命令行參數、目標文件。不支持gcc的inline方式的匯編。例，f.c
#include<stdio.h>
int main(int argc, char* argv[]){
printf("Hello\n");
return 0;
}
編譯：icc -c f.cpp -o f.o
鏈接：icc f.o -o f
運行：./f
注意，編譯與鏈接都由icc來完成，icc常用命令行參數：
-o 輸出文件命名
-I include路徑
-L lib路徑
-l 包含的lib名
-c 僅生成目標文件(*.o),不鏈接
-On n=0,1,2,3 編譯器優化選項，n=0關閉編譯器優化，n=3使用最激進的優化
-c99[-] 打開/關閉 c99規范的支持
詳細的請參照icc的manpage.
2、ifort
Intel Fortran編譯器支持F77/90/95標准並與CFV(Compaq Visual Fortran)兼容。例，f.f90
program f
print *, "Hello"
stop
end
編譯：ifort -c f.f90 -o f.o
鏈接：ifort f.o -o f
運行：./f
編譯與連接同樣由ifort來完成，ifort常用命令行參數：
-o 輸出文件命名
-I include路徑
-L lib路徑
-l 包含的lib名
-c 僅生成目標文件(*.o),不鏈接
-On n=0,1,2,3 編譯器優化選項，n=0關閉編譯器優化，n=3使用最激進的優化
-std90 使用F90標准編譯
-std95 使用F 95標准編譯
-f77rtl 編譯使用F77運行方式的代碼（用於解決特殊問題）
These options optimize application performance for a particular Intel? processor or family of processors. The compiler generates code that takes advantage of features of the specified processor.
Option
Description
tpp5 or G5 Optimizes for Intel? Pentium? and Pentium? with MMX? technology processors.
tpp6 or G6 Optimizes for Intel? Pentium? Pro, Pentium? II and Pentium? III processors.
tpp7 or G7 Optimizes for Intel? Pentium? 4, Intel? Xeon?, Intel? Pentium? M processors, and Intel? Pentium? 4 processors with Streaming SIMD Extensions 3 (SSE3) instruction support.
On Intel? EM64T systems, only option tpp7 (Linux) or G7 (Windows) is valid.
About tpp:
http://www.ncsa.illinois.e/UserInfo/Resources/Software/Intel/Compilers/9.0/main_for/mergedProjects/copts_for/common_options/option_tpp567_g567.htm
https://wiki.ke.e/display/SCSC/Compilers+and+Libraries
Intel Fortran Compiler Options: http://geco.mines.e/guide/ifort.html
Intel(R) Fortran Compiler Options: http://www.rcac.pure.e/userinfo/resources/common/compile/compilers/intel/man/ifort.txt
ifort編譯器提供了非常多的優化參數
$ ifort --help | more 查看就可以
也可以定位到某個參數
$ifort --help | grep -5 '-mkl'
-5表示顯示查找到的行及下面5行的內容。
3、Intel MKL數學庫針對Intel系列處理器進行了專門的優化，主要包含的庫有：
基本線形代數運算(BLAS)
向量與向量、向量與矩陣、矩陣與矩陣的運算
稀疏線形代數運算
快速傅立葉變換(單精度/雙精度)
LAPACK(求解線形方程組、最小方差、特徵值、Sylvester方程等)
向量數學庫(VML)
向量統計學庫(VSL)
高級離散傅立葉變換
編譯:
icc multi.c -I/opt/intel/mkl/include –L/intel/mkl/lib –lmpi_ipf –o multi
4、MPI程序編譯
消息傳遞介面(MPI)並行程序設計模型程序的編譯命令。例，f.c
include<stdio.h>
#include<mpi.h>
main(argc,argv)
int argc;
char *argv[];
{
char name[BUFSIZ];
int length;
MPI_Init(&argc,&argv);
MPI_Get_processor_name(name, &length);
printf("%s: hello world\n", name);
MPI_Finalize();
}
編譯與連接均使用mpicc,參數與mpicc中定義的編譯器相同，這里與icc相同。
mpicc –c hello.c –o hello.o
mpicc hello.o –o hello
運行使用mpirun 命令，將運行需要的節點定義在文件中並在-machinfile中制定。
文件: nodelist
node1
node1
node2
node3
運行：
$mpirun –machefile nodelist –np 4 ./hello
node1: hello world
node1: hello world
node2: hello world
node3: hello world
5、32位向64位的移植
32位程序到64位移植中應注意的常見問題：
數據截斷：
由於long類型變數的運算（賦值、比較、移位等）產生。long定義在x86上為32bits,而在ia64上為64bits.容易在與int型變數運算時出現異常。
處理方法：盡量避免不同類型變數間的運算,避免將長度較長的變數賦值到較短的變數中，統一變數長度可以解決這個問題。簡單的對於32位轉移到64位可以將所有long定義轉換為int定義。
⑥ gcc編譯鏈接文件耗時
GCC 編譯鏈接文件耗時可能受多種因素影響，以下是一些可能的原因和解決方法：
大規模代碼庫：如果您的代碼庫很殲蔽大，例如包含大量源文件、頭文件和庫文件，那神改森么編譯鏈接時需要的時間就會更長。您可以考慮使用增量編譯，只編譯發生更改的文件，以縮短編譯鏈接時間。
編譯器選項：某些編譯器選項可能會影響編譯鏈接的時間。例如，啟用優化選項可能會使編譯鏈接時間更長。您可以嘗試調整編譯器選項來優化編譯鏈接時間。例如，可以使用 -O0 選項關閉優化。但是，請注意，關閉優化可能會影響代碼的性能和效率。
硬體配置：編譯鏈接時間也可能受到硬體配置的影響。如果您的計算機配置較低，例如 CPU、內存和硬碟空間較小，那麼編譯鏈接時間可能會更長。您可以嘗試升級硬游畝件配置，例如增加內存和更換更快的硬碟。
多線程編譯：GCC 支持多線程編譯，可以同時編譯多個源文件，從而加快編譯鏈接時間。您可以使用 -j 選項指定要使用的線程數。例如，使用 -j4 選項將使用 4 個線程編譯鏈接。
使用預編譯頭文件：如果您的代碼庫包含大量公共頭文件，可以使用預編譯頭文件來加快編譯鏈接時間。預編譯頭文件包含公共頭文件的預編譯版本，可以在編譯鏈接時重用，從而減少編譯鏈接時間。
總之，GCC 編譯鏈接時間受多種因素影響，您可以嘗試使用上述方法來優化編譯鏈接時間。
⑦ C語言編程問題 *volatile....
volatile就是不要讓編譯器優化這個變數。讀寫變數的時候直接對內存操作。如果優化了，會先讀取寄存器的值，（這樣就有可能和內存中的值不一樣了）。常用於多線程變數，中斷變數等
⑧ Java代碼的優化方法有哪些
說到代碼優化，每個人或多或少都掌握一到兩種方法，但是這樣的方法對提升代碼運行效率效果不大，最重要是對代碼的重視和了解，這樣才能提升代碼的運行效率。在進行代碼優化的過程中，方法是非常重要的，多掌握幾種方法，根據代碼的不同情況選擇適合的方法進行優化。下面電腦培訓為大家介紹Java代碼優化的幾種方法。
1、使用指定類、方法的final修飾符
具有final修飾符的類不可派生。在Java核心API中，有許多最終應用程序的例子，例如java.lang.String，整個類都是final。為類指定final修飾符允許繼承類，並且為方法指定final修飾符允許覆蓋該方法。如果將類指定為final，IT培訓認為該類的所有方法都是final。Java編譯器將尋找內聯所有最終方法的機會。內聯對於提高Java操作的效率非常重要。這可以將性能平均提高50％。
2、重用對象
String對象的使用是非常重要的，StringBuilder/StringBuffer並不是字元串連接。由於Java虛擬機需要時間來生成對象，所以將來垃圾收集和處理這些對象可能需要一些時間。因此，生成太多對象將對程序的性能產生很大影響。
3、使用局部變數
調用方法時傳遞的參數以及在調用中創建的臨時變數都保存在堆棧中，速度更快。其他變數（如靜態變數和實例變數）在堆中創建並且速度較慢。此外，昆明北大青鳥發現在堆棧中創建的變數，當方法完成運行時，內容消失，不需要進行額外的垃圾收集。
4、及時關閉流
在Java編程過程中，在執行資料庫連接和I/O流操作時要小心。使用後，北大青鳥雲南嘉薈校區官網建議應及時關閉以釋放資源。因為這些大型物體的操作會導致系統的大量開銷，稍微粗心會導致嚴重的後果。