A. oracle資料庫約200W數據查詢非常慢，查詢需要10幾秒，經常查詢超時，這個正常嗎有沒有什麼好的辦法解決
使用explain plan FOR，執行計劃，看是否使用了索引進行查詢
代碼：通過查詢執行計劃，查看Oracle查詢語句是否使用索引
B. 大蝦請進：oracle資料庫超大數據量的處理
通過使用一些輔助性工具來找到程序中的瓶頸，然後就可以對瓶頸部分的代碼進行優化。一般有兩種方案：即優化代碼或更改設計方法。我們一般會選擇後者，因為不去調用以下代碼要比調用一些優化的代碼更能提高程序的性能。而一個設計良好的程序能夠精簡代碼，從而提高性能。
下面將提供一些在java程序的設計和編碼中，為了能夠提高JAVA程序的性能，而經常採用的一些方法和技巧。
1．對象的生成和大小的調整。
JAVA程序設計中一個普遍的問題就是沒有好好的利用JAVA語言本身提供的函數，從而常常會生成大量的對象（或實例）。由於系統不僅要花時間生成對象，以後可能還需花時間對這些對象進行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。
例1：關於String ,StringBuffer，+和append
JAVA語言提供了對於String類型變數的操作。但如果使用不當，會給程序的性能帶來影響。如下面的語句：
String name=new String("HuangWeiFeng");
System.out.println(name+"is my name");
看似已經很精簡了，其實並非如此。為了生成二進制的代碼，要進行如下的步驟和操作：
(1) 生成新的字元串 new String（STR_1);
(2) 復制該字元串;
(3) 載入字元串常量"HuangWeiFeng"（STR_2);
(4) 調用字元串的構架器（Constructor）;
(5) 保存該字元串到數組中（從位置0開始）;
(6) 從java.io.PrintStream類中得到靜態的out變數;
(7) 生成新的字元串緩沖變數new StringBuffer(STR_BUF_1);
(8) 復制該字元串緩沖變數;
(9) 調用字元串緩沖的構架器（Constructor）;
(10) 保存該字元串緩沖到數組中（從位置1開始）;
(11) 以STR_1為參數，調用字元串緩沖(StringBuffer)類中的append方法;
(12) 載入字元串常量"is my name"(STR_3);
(13) 以STR_3為參數，調用字元串緩沖(StringBuffer)類中的append方法;
(14) 對於STR_BUF_1執行toString命令;
(15) 調用out變數中的println方法，輸出結果。
由此可以看出，這兩行簡單的代碼，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五個對象變數。這些生成的類的實例一般都存放在堆中。堆要對所有類的超類，類的實例進行初始化，同時還要調用類極其每個超類的構架器。而這些操作都是非常消耗系統資源的。因此，對對象的生成進行限制，是完全有必要的。
經修改，上面的代碼可以用如下的代碼來替換。
StringBuffer name=new StringBuffer("HuangWeiFeng");
System.out.println(name.append("is my name.").toString());
系統將進行如下的操作：
(1) 生成新的字元串緩沖變數new StringBuffer(STR_BUF_1);
(2) 復制該字元串緩沖變數;
(3) 載入字元串常量"HuangWeiFeng"(STR_1);
(4) 調用字元串緩沖的構架器（Constructor）;
(5) 保存該字元串緩沖到數組中（從位置1開始）;
(6) 從java.io.PrintStream類中得到靜態的out變數;
(7) 載入STR_BUF_1;
(8) 載入字元串常量"is my name"(STR_2);
(9) 以STR_2為參數，調用字元串緩沖(StringBuffer)實例中的append方法;
(10) 對於STR_BUF_1執行toString命令(STR_3);
(11)調用out變數中的println方法，輸出結果。
由此可以看出，經過改進後的代碼只生成了四個對象變數：STR_1,STR_2,STR_3和STR_BUF_1.你可能覺得少生成一個對象不會對程序的性能有很大的提高。但下面的代碼段2的執行速度將是代碼段1的2倍。因為代碼段1生成了八個對象，而代碼段2隻生成了四個對象。
代碼段1：
String name= new StringBuffer("HuangWeiFeng");
name+="is my";
name+="name";
代碼段2：
StringBuffer name=new StringBuffer("HuangWeiFeng");
name.append("is my");
name.append("name.").toString();
因此，充分的利用JAVA提供的庫函數來優化程序，對提高JAVA程序的性能時非常重要的.其注意點主要有如下幾方面；
(1) 盡可能的使用靜態變數（Static Class Variables）
如果類中的變數不會隨他的實例而變化，就可以定義為靜態變數，從而使他所有的實例都共享這個變數。
例：
public class foo
{
SomeObject so=new SomeObject();
}
就可以定義為：
public class foo
{
static SomeObject so=new SomeObject();
}
(2) 不要對已生成的對象作過多的改變。
對於一些類(如：String類)來講，寧願在重新生成一個新的對象實例，而不應該修改已經生成的對象實例。
例：
String name="Huang";
name="Wei";
name="Feng";
上述代碼生成了三個String類型的對象實例。而前兩個馬上就需要系統進行垃圾回收處理。如果要對字元串進行連接的操作，性能將得更差，因為系統將不得為此生成更多得臨時變數，如上例1所示。
(3) 生成對象時，要分配給它合理的空間和大小JAVA中的很多類都有它的默認的空間分配大小。對於StringBuffer類來講，默認的分配空間大小是16個字元。如果在程序中使用StringBuffer的空間大小不是16個字元，那麼就必須進行正確的初始化。
(4) 避免生成不太使用或生命周期短的對象或變數。對於這種情況，因該定義一個對象緩沖池。以為管理一個對象緩沖池的開銷要比頻繁的生成和回收對象的開銷小的多。
(5) 只在對象作用范圍內進行初始化。JAVA允許在代碼的任何地方定義和初始化對象。這樣，就可以只在對象作用的范圍內進行初始化。從而節約系統的開銷。
例：
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改為：
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}
2．異常(Exceptions)
JAVA語言中提供了try/catch來發方便用戶捕捉異常，進行異常的處理。但是如果使用不當，也會給JAVA程序的性能帶來影響。因此，要注意以下兩點：
(1) 避免對應用程序的邏輯使用try/catch
如果可以用if,while等邏輯語句來處理，那麼就盡可能的不用try/catch語句。
(2) 重用異常
在必須要進行異常的處理時，要盡可能的重用已經存在的異常對象。以為在異常的處理中，生成一個異常對象要消耗掉大部分的時間。
3. 線程(Threading)
一個高性能的應用程序中一般都會用到線程。因為線程能充分利用系統的資源。在其他線程因為等待硬碟或網路讀寫而 時，程序能繼續處理和運行。但是對線程運用不當，也會影響程序的性能。
例2：正確使用Vector類
Vector主要用來保存各種類型的對象（包括相同類型和不同類型的對象）。但是在一些情況下使用會給程序帶來性能上的影響。這主要是由Vector類的兩個特點所決定的。第一，Vector提供了線程的安全保護功能。即使Vector類中的許多方法同步。但是如果你已經確認你的應用程序是單線程，這些方法的同步就完全不必要了。第二，在Vector查找存儲的各種對象時，常常要花很多的時間進行類型的匹配。而當這些對象都是同一類型時，這些匹配就完全不必要了。因此，有必要設計一個單線程的，保存特定類型對象的類或集合來替代Vector類.用來替換的程序如下（StringVector.java）：
public class StringVector
{
private String [] data;
private int count;
public StringVector()
{
this(10); // default size is 10
}
public StringVector(int initialSize)
{
data = new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + 1);
data[count++] = str;
}
private void ensureCapacity(int minCapacity)
{
int oldCapacity = data.length;
if (minCapacity > oldCapacity)
{
String oldData[] = data;
int newCapacity = oldCapacity * 2;
data = new String[newCapacity];
System.array(oldData, 0, data, 0, count);
}
}
public void remove(String str)
{
if(str == null) { return; // ignore null str }
for(int i = 0; i < count; i++)
{
// check for a match
if(data[i].equals(str))
{
System.array(data,i+1,data,i,count-1); // data
// allow previously valid array element be gc'd
data[--count] = null;
return;
}
}
}
public final String getStringAt(int index)
{
if(index < 0) { return null; }
else if(index > count) { return null; // index is > # strings }
else { return data[index]; // index is good }
}
}
因此，代碼：
Vector Strings=new Vector();
Strings.add("One");
Strings.add("Two");
String Second=(String)Strings.elementAt(1);
可以用如下的代碼替換：
StringVector Strings=new StringVector();
Strings.add("One");
Strings.add("Two");
String Second=Strings.getStringAt(1);
這樣就可以通過優化線程來提高JAVA程序的性能。用於測試的程序如下（TestCollection.java）:
import java.util.Vector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect = new TestCollection();
if(args.length == 0)
{
System.out.println("Usage: java TestCollection [ vector | stringvector ]");
System.exit(1);
}
if(args[0].equals("vector"))
{
Vector store = new Vector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
store.addElement("string");
}
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
String result = (String)store.elementAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector"))
{
StringVector store = new StringVector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) { store.add("string"); }
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) {
String result = store.getStringAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
關於線程的操作，要注意如下幾個方面：
(1) 防止過多的同步
如上所示，不必要的同步常常會造成程序性能的下降。因此，如果程序是單線程，則一定不要使用同步。
(2) 同步方法而不要同步整個代碼段
對某個方法或函數進行同步比對整個代碼段進行同步的性能要好。
(3) 對每個對象使用多」鎖」的機制來增大並發。
一般每個對象都只有一個」鎖」，這就表明如果兩個線程執行一個對象的兩個不同的同步方法時，會發生」死鎖」。即使這兩個方法並不共享任何資源。為了避免這個問題，可以對一個對象實行」多鎖」的機制。如下所示：
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4．輸入和輸出(I/O)
輸入和輸出包括很多方面，但涉及最多的是對硬碟，網路或資料庫的讀寫操作。對於讀寫操作，又分為有緩存和沒有緩存的；對於資料庫的操作，又可以有多種類型的JDBC驅動器可以選擇。但無論怎樣，都會給程序的性能帶來影響。因此，需要注意如下幾點：
(1) 使用輸入輸出緩沖
盡可能的多使用緩存。但如果要經常對緩存進行刷新（flush）,則建議不要使用緩存。
(2) 輸出流(Output Stream)和Unicode字元串
當時用Output Stream和Unicode字元串時，Write類的開銷比較大。因為它要實現Unicode到位元組(byte)的轉換.因此，如果可能的話,在使用Write類之前就實現轉換或用OutputStream類代替Writer類來使用。
(3) 當需序列化時使用transient
當序列化一個類或對象時，對於那些原子類型（atomic）或可以重建的原素要表識為transient類型。這樣就不用每一次都進行序列化。如果這些序列化的對象要在網路上傳輸，這一小小的改變對性能會有很大的提高。
(4) 使用高速緩存（Cache）
對於那些經常要使用而又不大變化的對象或數據，可以把它存儲在高速緩存中。這樣就可以提高訪問的速度。這一點對於從資料庫中返回的結果集尤其重要。
(5) 使用速度快的JDBC驅動器（Driver）
JAVA對訪問資料庫提供了四種方法。這其中有兩種是JDBC驅動器。一種是用JAVA外包的本地驅動器；另一種是完全的JAVA驅動器。具體要使用哪一種得根據JAVA布署的環境和應用程序本身來定。
5.一些其他的經驗和技巧
(1) 使用局部變數。
(2) 避免在同一個類中動過調用函數或方法(get或set)來設置或調用變數。
(3) 避免在循環中生成同一個變數或調用同一個函數（參數變數也一樣）。
(4) 盡可能的使用static,final,private等關鍵字。
(5) 當復制大量數據時，使用System.array()命令。
C. Oracle等資料庫數據量特別大的時候怎樣從程序和SQL語句方面優化使查詢速度加快
一般最抄常用的大數據量優襲化：
1、創建分區表，使查詢時的大表盡量分割成小表。Oracle提供范圍分區、列表分區、Hash分區以及復合分區，具體選擇哪種分區最優，需要根據你的業務數據來確定。
2、創建索引，創建合適的索引可以大大提高查詢速度。但是你的這張大表如果會頻繁的進行update、insert等操作，索引會導致這些操作變慢。就有可能需要進行動態索引的使用。
3、優化復雜SQL；對復雜的SQL進行合理的優化，這個有時候也需要根據你的數據情況來優化，可以參考一些SQL語句優化方面的文檔。
D. oracle資料庫越來越慢怎麼辦一般怎麼處理哪位網友知道非常感謝！
什麼操作系統，unix， topas 看看系統資源； windows更好看系統資源其情況了；
生成sp報告看看那個語句性能有問題； 還有慢是怎麼慢法；每個語句都慢？
E. oracle哪個工具自動檢測系統瓶頸並給出建議
ADDM(Automatic DatabaseDiagnostic Monitor)是植入Oracle資料庫的一個自診斷引擎.ADDM 通過檢查和分析AWR獲取的數據來判斷Oracle資料庫中可能的問題.
在Oracle9i及之前，DBA們已經擁有了很多很好用的性能分析工具，比如，tkprof、sql_trace、statspack、setevent 10046&10053等等。這些工具能夠幫助DBA很快的定位性能問題。但這些工具都只給出一些統計數據，然後再由DBA們根據自己的經驗進行優化。
Oracle10g中推出了新的優化診斷工具：資料庫自動診斷監視工具（Automatic Database Diagnostic Monitor :ADDM）和SQL優化建議工具（SQL Tuning Advisor: STA）。這兩個工具的結合使用，能使DBA節省大量優化時間，也大大減少了系統宕機的危險。簡單點說，ADDM就是收集相關的統計數據到自動工作量知識庫(Automatic Workload Repository :AWR)中，而STA則根據這些數據，給出優化建議。
例如，一個系統資源緊張，出現了明顯的性能問題，由以往的辦法，做個一個statspack快照，等30分鍾，再做一次。查看報告，發現』 dbfile scattered read』事件在top 5 events裡面。根據經驗，這個事件一般可能是因為缺少索引、統計分析信息不夠新、熱表都放在一個數據文件上導致IO爭用等原因引起的。根據這些經驗，我們需要逐個來定位排除，比如查看語句的查詢計劃、查看user_tables的last_analysed子段，檢查熱塊等等步驟來最後定位出原因，並給出優化建議。但是，有了STA以後，它就可以根據ADDM採集到的數據直接給出優化建議，甚至給出優化後的語句。
ADDM能發現定位的問題包括：
•操作系統內存頁入頁出問題
•由於Oracle負載和非Oracle負載導致的CPU瓶頸問題
•導致不同資源負載的TopSQL語句和對象——CPU消耗、IO帶寬佔用、潛在IO問題、RAC內部通訊繁忙
•按照PLSQL和JAVA執行時間排的Top SQL語句.
•過多地連接 (login/logoff).
•過多硬解析問題——由於sharedpool過小、書寫問題、綁定大小不適應、解析失敗原因引起的。
•過多軟解析問題
•索引查詢過多導致資源爭用.
•由於用戶鎖導致的過多的等待時間(通過包dbms_lock加的鎖)
•由於DML鎖導致的過多等待時間(例如鎖住表了)
•由於管道輸出導致的過多等待時間(如通過包dbms_pipe.put進行管道輸出)
•由於並發更新同一個記錄導致的過多等待時間(行級鎖等待)
•由於ITL不夠導致的過多等待時間（大量的事務操作同一個數據塊）
•系統中過多的commit和rollback(logfilesync事件).
•由於磁碟帶寬太小和其他潛在問題（如由於logfile太小導致過多的checkpoint，MTTR設置問題，過多的undo操作等等）導致的IO性能問題I
•對於DBWR進程寫數據塊，磁碟IO吞吐量不足
•由於歸檔進程無法跟上redo日至產生的速度，導致系統變慢
•redo數據文件太小導致的問題
•由於擴展磁碟分配導致的爭用
•由於移動一個對象的高水位導致的爭用問題
•內存太小問題——SGATarget, PGA, Buffer Cache, Shared Pool
•在一個實例或者一個機群環境中存在頻繁讀寫爭用的熱塊
•在一個實例或者一個機群環境中存在頻繁讀寫爭用的熱對象
•RAC環境中內部通訊問題
•LMS進程無法跟上導致鎖請求阻塞
•在RAC環境中由於阻塞和爭用導致的實例傾斜
•RMAN導致的IO和CPU問題
•Streams和AQ問題
•資源管理等待事件
ADDM提供了一個整體的優化方案.基於一段時間內的AWRsnapshots(默認一小時一次)可以執行ADDM 分析,它可以幫我們診斷在這段期間內資料庫可能存在的瓶頸.
ADDM分析的目標是減小吞吐量的度量值, 在這里我們將它稱為"DB TIME".DB TIME是一個累積值(資料庫伺服器處理用戶請求所花費的時間).它包括了等待時間和CPU處理的時間(針對所有活躍的用戶進程而言),可以通過查詢下面兩個視圖來獲得它的值: V$SESS_TIME_MODEL,V$SYS_TIME_MODEL.
AWR收集的數據時放到內存中（sharepool），通過一個新的後台進程MMON定期寫到磁碟中。所以10g的sharepool要求比以前版本更大，一般推薦比以前大15-20%。
注意: ADDM不會將處理用戶響應時間作為調優的目標,你應該使用"TRACE"技術來監控它.
通過減小"DBTIME", 使用同樣多的系統資源,資料庫伺服器可以處理更多的用戶請求,也就是提高了吞吐量. 通過ADDM報告的問題是按照DBtime排序的.