flushpool礦池

① hbase htable是否有效，過期

1.HTablePool的基本使用方式：

由於HTable對象不是線程安全的，因此HBase提供HTablePool來支持多線程寫入hbase，多線程同時從HTablePool中取出HTable並寫入是安全的。HTablePool的使用方法類似資料庫連接，使用時從HTablePool中取出一個HTable，使用完後再close放回HTablePool中。
Put put = new Put(rowkey);
put.add(LOG_COLUMN_FAMILY,HOST_NAME_QUALIFIER,values[0]);
HTableInterface table = HBaseClientFactory.getHTableByName(RAW_LOG_TABLE);
try {
table.put(put);
} catch (IOException e) {
throw new RuntimeException("Put Log meet exception",e);
}finally {
HBaseClientUtil.closeHTable(table);
}

2.HTablePool的maxsize。

HTablePool有一個maxsize，HTablePool針對每個表都有一個Pool，maxsize表示這個Pool的最大大小,在使用HTablePool的過程中我們發現這個值還是有需要注意的地方。

在多線程使用HTablePool拿到同一個表的HTable時，如果線程個數大於maxsize會導致寫入始終是autoflush！
public HTableInterface getTable(String tableName) {
// call the old getTable implementation renamed to findOrCreateTable
HTableInterface table = findOrCreateTable(tableName);
// return a proxy table so when user closes the proxy, the actual table
// will be returned to the pool
return new PooledHTable(table);
}

當拿到HTable時會創建一個HTable對象並包裝成一個PooledHTable對象。Pooled做了什麼納，其他方法都沒變，只是在close時有所不同：
public void close() throws IOException {
returnTable(table);
}
private void returnTable(HTableInterface table) throws IOException {
// this is the old putTable method renamed and made private
String tableName = Bytes.toString(table.getTableName());
if (tables.size(tableName) >= maxSize) {
// release table instance since we're not reusing it
this.tables.remove(tableName, table);
this.tableFactory.releaseHTableInterface(table);
return;
}
tables.put(tableName, table);
}

可以看到如果tables.size大於maxsize，此時會去掉一個保存的HTable對象，而releaseHTableInterface實際調用的就是HTable的close方法，close方法又會強制flushHTable的buffer，因此，如果我們想不使用autoflush提升寫入速度失效。

3.HTablePool type。

HTablePool提供了幾種方式：ReusablePool，RoundRobinPool，ThreadLocalPool。默認的是reusable，由於2的原因，我們也可以考慮使用ThreadLocal的Pool，這樣多線程寫入時分別取自己線程的Pool，這樣互不影響，寫入的效率也會比較高。
static class ThreadLocalPool<R> extends ThreadLocal<R> implements Pool<R> {
private static final Map<ThreadLocalPool<?>, AtomicInteger> poolSizes = new HashMap<ThreadLocalPool<?>, AtomicInteger>();

public ThreadLocalPool() {
}

@Override
public R put(R resource) {
R previousResource = get();
if (previousResource == null) {
AtomicInteger poolSize = poolSizes.get(this);
if (poolSize == null) {
poolSizes.put(this, poolSize = new AtomicInteger(0));
}
poolSize.incrementAndGet();
}
this.set(resource);
return previousResource;
}

4.HTable的WriteBufferSize和autoflush

如果想追求寫入的速度我們可以設置setWriteBufferSize為一個比較大的大小比如1M並autoflush為false，這樣寫入的速度會有幾十倍的提升，但如果BufferSize比較大也會帶來寫入不夠實時的問題，尤其有些表的數據很小會很久都不flush。因此，我們可以添加按時間間隔的flush方式。
@Override
public void put(final List<Put> puts) throws IOException {
super.put(puts);
needFlush();
}

private void needFlush() throws IOException {
long currentTime = System.currentTimeMillis();
if ((currentTime - lastFlushTime.longValue()) > flushInterval) {
super.flushCommits();
lastFlushTime.set(currentTime);
}
}

② 資料庫重啟 sharepool 清空嗎

資料庫重啟 sharepool 清空嗎
在Oracle9i里，Oracle提供了一個內部事件，用以強制刷新Buffer Cache。
其語法為:
alter session set events 'immediate trace name flush_cache level 1';
或者:
alter session set events = 'immediate trace name flush_cache';
類似的也可以使用alter system系統級設置:
alter system set events = 'immediate trace name flush_cache';
在Oracle10g中，Oracle提供一個新的特性，可以通過如下命令刷新Buffer Cache:

alter system flush buffer_cache;

③ oracle keep pool會不會自動緩存cache的表數據的更改

ORACLE緩存是把ORACLE近期查看的語句防止在ORACLE設定的緩存當中
ORACLE緩存表是把表某個表放置在緩存當中，緩存是ORACLE在內存中的一個分區
表緩存的設定
oracle中如何將表緩存到內存中
由於在一些靜態資料表在資料庫中被頻繁的訪問，所以可以考慮將這些數據量不大的表緩存到內存當中。
將fisher表緩存到內存中
alter table fisher cache;方法一
2）alter table fisher storage(buffer_pool keep);方法二
--取消緩存
1）alter table fisher nocache;
2）alter table fisher storage(buffer_pool default);
select table_name,OWNER,cache,buffer_pool from dba_tables where table_name='FISHER'; --查看是否緩存
select * from dba_segments where segment_name='FISHER' ; --查看錶大小
方法一： cache是將表緩存到share pool 中，該操作直接將表緩存的熱端，受LRU演算法控制。
方法二：將表緩存到一個固定的內存空間中，默認情況下buffer_pool空間為0,。需手動設置空間大小。
設置空間大小：alter system set db_keep_cache_size=50M scope=both sid=『*';
--表緩存
alter table table_name cache = alter table table_name storage(buffer_pool default);
alter table table_name storage(buffer_pool keep);
--已經加入到KEEP區的表想要移出緩存，使用
alter table table_name nocache;
--查看哪些表被放在緩存區 但並不意味著該表已經被緩存
select table_name from dba_tables where buffer_pool='keep';
--查詢到該表是否已經被緩存
select table_name,cache,buffer_pool from user_TABLES where cache like '%Y';
--查詢當前用戶下表的情況
select table_name,cache,buffer_pool from user_TABLES;
--對於普通LOB類型的segment的cache方法
alter table t2 modify lob(c2) (storage (buffer_pool keep) cache);
--取消緩存
alter table test modify lob(address) (storage (buffer_pool keep) nocache);
keep Buffer Pool
Keep Buffer Pool 的作用是緩存那些需要經常查詢的對象但又容易被默認緩沖區置換出去的對象，按慣例，Keep pool設置為合理的大小，以使其中存儲的對象不再age out，也就是查詢這個對象的操作不會引起磁碟IO操作，可以極大地提高查詢性能。
默認的情況下 db_keep_cache_size=0，未啟用，如果想要啟用，需要手工設置db_keep_cache_size的值，設置了這個值之後 db_cache_size 會減少。
並不是我們設置了keep pool 之後，熱點表就一定能夠緩存在 keep pool ，keep pool 同樣也是由LRU 鏈表管理的，當keep pool 不夠的時候，最先緩存到 keep pool 的對象會被擠出，不過與default pool 中的 LRU 的管理方式不同，在keep pool 中表永遠是從MRU 移動到LRU，不會由於你做了FTS而將表緩存到LRU端，在keep pool中對象永遠是先進先出。當oracle發現你的表太太，大過你設定keep pool的大小是，根本就不會放到keep池中去的（如keep pool設定100M ，設定的用戶緩存的表為200M）。可以用select segment_name from dba_segments where BUFFER_POOL = 'KEEP';語句查看便知。
10g中SGA自動管理，ORACLE並不會為我們管理keep pool ，ORACLE只會管理default pool。
查看 keep pool 大小
SQL> select component,current_size from v$sga_dynamic_components
2 where component='KEEP buffer cache';
COMPONENT CURRENT_SIZE
---------------------------------------------------------------- ------------
KEEP buffer cache 0
手動分配keep pool
SQL> show parameter keep
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_keep string
control_file_record_keep_time integer 7
db_keep_cache_size big integer 0
SQL> alter system set db_keep_cache_size=10m;
系統已更改。
SQL> show parameter keep
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_keep string
control_file_record_keep_time integer 7
db_keep_cache_size big integer 16M這里keep pool 16M，可我前面設置命名是10m了？
SQL> select component,current_size from v$sga_dynamic_components where component='KEEP buffer cache';
COMPONENT CURRENT_SIZE
---------------------------------------------------------------- ------------
KEEP buffer cache 16777216 這里keep pool 16M，可我前面設置命名是10m了？
查看keep pool剩餘大小
SQL> select p.name,a.cnum_repl "total buffers",a.anum_repl "free buffers" from x$kcbwds a, v$buffer_pool p
2 where a.set_id=p.LO_SETID and p.name='KEEP';
NAME total buffers free buffers
-------------------- ------------- ------------
KEEP 1984 1984
可以看到沒有使用過keep 池
指定table的緩存池
SQL>create table test as select * from dba_objects;;
Table created.
SQL> alter table test storage(buffer_pool keep);
Table altered.
或者是
create table test storage(buffer_pool keep) as select * from dba_objects;
查看放入Keep的對象
SQL> select segment_name from dba_segments where BUFFER_POOL = 'KEEP';
SEGMENT_NAME
--------------------------------------------------------------------------------
TEST
SQL> /
NAME total buffers free buffers
-------------------- ------------- ------------
KEEP 1984 1962 可以看到使用了22個block
查看以上的表佔用了db_keep_cache_size 多大的空間？
SQL> select substr(sum(b.NUMBER_OF_BLOCKS) * 8129 / 1024 / 1024, 1, 5) || 'M'
from (SELECT o.OBJECT_NAME, COUNT(*) NUMBER_OF_BLOCKS
FROM DBA_OBJECTS o, V$BH bh, dba_segments dd
WHERE o.DATA_OBJECT_ID = bh.OBJD
AND o.OWNER = dd.owner
and dd.segment_name = o.OBJECT_NAME
and dd.buffer_pool != 'DEFAULT'
GROUP BY o.OBJECT_NAME
ORDER BY COUNT(*)) b; 2 3 4 5 6 7 8 9
SUBSTR(SUM(
-----------
3.643M
SQL> select table_name,cache,blocks from dba_tables where wner='ROBINSON' and buffer_pool='KEEP';
TABLE_NAME CACHE BLOCKS
------------------------------ -------------------- ----------
TEST N 22
可以看到這個表的 22個block 全部cache 到 keep pool ，這里的cache 欄位表明 這個表 還沒有使用 這個命令 alter table test cache,如果 使用了 alter table test cache ,命令，那麼 N 將變成Y
總結：如果表經常使用，而且表較小，可以設置 keep pool ，將table 全部 cache 到 keep pool, keep pool 要麼 全部 cache 一個table ，要麼不cache 。所以，對於大表來說，如果想要 cache 到 keep pool， 就需要設置 較大的 keep pool ，以容納大的 table，否者就沒有作用了。
Recycle Buffer Pool
Recycle Buffer Pool正好相反。Recycle Buffer Pool用於存儲臨時使用的、不被經常使用的較大的對象，這些對象放置在Default Buffer Pool顯然是不合適的，這些塊會導致過量的緩沖區刷新輸出，而且不會帶來任何好處，因為等你想要再用這個塊時，它可已經老化退出了緩存。要把這些段與默認池和保持池中的段分開，這樣就不會導致默認池和保持池中的塊老化而退出緩存。
SQL> show parameter recyc
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
buffer_pool_recycle string
db_recycle_cache_size big integer 12M
recyclebin string on
如何將一個表放入Recycle Buffer Pool中：
SQL> alter table test1 storage (buffer_pool recycle);
Table altered.
很多老的文檔會提及buffer_pool_keep和buffer_pool_recycle 這兩個參數，其實這兩個參數已經廢棄，由新參數db_keep_cache_size和db_recycle_cache_size 替代：
SQL>select ISDEPRECATED,NAME from v$parameter where name = 'buffer_pool_keep';
ISDEP NAME
----- -----------------
TRUE buffer_pool_keep
=======================================================================================
--表緩存
alter table ..... storage(buffer_pool keep);
--查看哪些表被放在緩存區 但並不意味著該表已經被緩存
select table_name from dba_tables where buffer_pool='keep';
--查詢到該表是否已經被緩存
select table_name,cache,buffer_pool from user_TABLES where cache like '%Y';
--已經加入到KEEP區的表想要移出緩存，使用
alter table table_name nocache;
--批量插入ORACLE建議用
insert all into ...insert into ...select 1 from al;
insert all into ... insert into ...select 1 from al;
--查詢當前用戶下表的情況
select table_name,cache,buffer_pool from user_TABLES;
--對於普通LOB類型的segment的cache方法
alter table t2 modify lob(c2) (storage (buffer_pool keep) cache);
--取消緩存
alter table test modify lob(address) (storage (buffer_pool keep) nocache);
--查詢段
select segment_name,segment_type,buffer_pool from user_segments;
--對基於CLOB類型的對象的cache方法
alter table lob1 modify lob(c1.xmldata) (storage (buffer_pool keep) cache);
--查詢該用戶下所有表內的大欄位情況
select column_name,segment_name from user_lobs;
來一段Tom關於Multiple Buffer Pools的解釋，講解得很清楚：
實際上，這3 個池會以大體相同的方式管理塊；將塊老化或緩存的演算法並沒有根本的差異。這樣做的目標是讓DBA 能把段聚集到「熱」區（hot）、「溫」區（warm）和「不適合緩存」區（do not care to cache）。
理論上講，默認池中的對象應該足夠熱（也就是說，用得足夠多），可以保證一直呆在緩存中。緩存會把它們一直留在內存中，因為它們是非常熱門的塊。可能還有一些段相當熱門，但是並不太熱；這些塊就作為溫塊。這些段的塊可以從緩存刷新輸出，為不常用的一些塊（「不適合緩存」塊）騰出空間。為了保持這些溫段的塊得到緩存，可以採取下面的某種做法：將這些段分配到保持池，力圖讓溫塊在緩沖區緩存中停留得更久。將「不適合緩存」段分配到回收池，讓回收池相當小，以便塊能快速地進入緩存和離開緩存（減少管理的開銷）。這樣會增加DBA 所要執行的管理工作，因為要考慮3 個緩存，要確定它們的大小，還要為這些緩存分配對象。還要記住，這些池之間沒有共享，所以，如果保持池有大量未用的空間，即使默認池或回收池空間不夠用了，保持池也不會把未用空間交出來。總之，這些池一般被視為一種非常精細的低級調優設備，只有所有其他調優手段大多用過之後才應考慮使用。
按以上步驟把表storage到keep pool中，然後調用alter system flush buffer_cache清空緩存，再全表掃描該表並打開執行計劃跟蹤，發現有physical reads，如下：
第一次執行計劃如下：
----------------------------------------------------------
0 recursive calls
0 db block gets
253 consistent gets
251 physical reads
0 redo size
520 bytes sent via SQL*Net to client
469 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed
第二次執行計劃如下：
----------------------------------------------------------
0 recursive calls
0 db block gets
253 consistent gets
0 physical reads
0 redo size
520 bytes sent via SQL*Net to client
469 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed
不知道是否可以這樣理解：對於storage到keep pool中的表，第一次會直接physical reads 到keep pool中，下次就直接從keep pool中讀了。flush buffer_cache會清空keep pool，這個試驗就可以證明。
像上面這樣連續執行2次再看執行計劃，和不設置keep pool時的執行計劃應該一樣的，因為讀第二次時，也是從default cache中讀。但是當我們多讀幾個大表到buffer cache後，也就是替換原來從default cache中讀取的數據後，再去讀放入keep中的表時，就會發現keep確實起作用了，唉，終於明白怎麼一回事，害得我為flush buffer導致keep中的表也phisical郁悶了半天。
ORACLE緩存設置
Oracle緩存由兩個參數控制SGA_TARGET和PGA_AGGREGATE_TARGET，設置了這兩個參數，其他的基本內存部分都由Oracle自動配置為最優值，這也是Oracle推薦的方式。
SGA_TARGET 和PGA_AGGREGATE_TARGET是動態參數，可以在不重啟資料庫的情況下修改。但是SGA_TARGET受限於 sga_max_size，SGA_TARGET不能超過sga_max_size，所以要增大sga_target先要增大sga_max_size，而sga_max_size是靜態參數，修改sga_max_size必須重啟Oracle。
所以修改sga_target和pga_aggregate_target的過程如下：
1、修改sga_max_size
SQL>ALTER SYSTEM SET sga_max_size=4g scope=spfile;
2、重啟Oracle
3、設置參數sga_target和pga_aggregate_target，
alter system set sga_target=4G;
alter system set pga_aggregate_target=1g;
如果使用的是10g，已經是ASM, oracle會根據統計的信息，自動的來調整你的內存組件的大小，你只需要設置sga_target即可。當然你可以手動設置 db_cache_size，如果設置了的話，Oracle會在自動調整內存大小的時候把這個作為db_cache_size的最小值。
對於sga_target,在動態修改的時候，最大值不能操過sga_max_size, 如果是用scope=spfile這個方式來修改可以超過sga_max_size，應該此時sga_max_size也跟著變大了，如果超過的話。
Oracle 對資料庫的cache有他自己的計算的，10g以後，內存是動態的根據對你使用系統的統計來進行調整的，如果出現問題，這塊不是原因，你之所以db cache還沒有上去，可能是訪問的數據比較少，不過你加大db_cache_size的值，會保留這個內存空間的，但是也是一樣的，數據 load到內存里，才看得到變化。
數據訪問是什麼樣的訪問，你的系統是OLAP還是OLTP，這些應用上的東西對你的決定也有影響的，要謹記，資料庫的優化和維護，不僅僅是DBA來做的。如果是到了只能通過DBA來做這一步的話，就相當於看病已經到了拿手術刀這一步了。你的改變帶來的風險和代價最高。
要想減少磁碟讀,只能增大內存的使用.樓主可以看看這個視圖v$db_cache_size,並執行下面的查詢:
select block_size, size_for_estimate, size_factor, estd_physical_read_factor, estd_physical_reads from v$db_cache_advice;
Oracle在這個視圖中針對db_cache_size的大小會給出一些建議。
下面解釋幾個列的含義
size_for_estimate：估計的cache size大小
size_factor： 估計的cache size大小與當前大小的比值
estd_physical_reads：在估計的cache size大小情況下，會產生的物理讀數量
estd_physical_read_factor：估計的物理讀數量與當前物理讀數量的比值。
例子：
SIZE_FOR_ESTIMATE SIZE_FACTOR ESTD_PHYSICAL_READ_FACTOR ESTD_PHYSICAL_READS

④ Elasticsearch中refresh和flush的區別是什麼

使用bulk API初次索引的時候，把 replica 設置為 0增大 threadpool.index.queue_size增大 indices.memory.index_buffer_size增大 index.translog.flush_threshold_ops增大 index.translog.sync_interval增大 index.engine.robin.refresh_interval

⑤ 近期資料庫出現共享池鎖等待（latch: shared pool)

解決共享池latch爭用
避免unnecessary heaps
避免和減少由於共享sql statements帶來的碎片
避免_kghdsidx_count=1
避免flush shared pool
避免shared pool reserved free list碎片

⑥ oracle的緩存怎麼清除

altersystemflashbuffer_cache;

⑦ 在JSP頁面有關out.flush()異常

在JSP的<%%>中不可以out.flush()來沖掉前面output。
在Servlet中可以用out.flush()這么做。（但你讓那個主Thread停頓3秒沒有錯誤，apache catalina會在output時候停3秒）

雖然說JSP本質就是Servlet，但那其實是JSP頁在第一次訪問後被Compile成Java servlet class，此時JSP才等於Servlet。

而JSP頁面中每一行，在Complile的時候，都相當於out.println();（比如：JSP中有一行<title>abc</title>, 那麼其對應的Compile之後的Servlet必定有一行out.println("<title>abc</title>");）

所以，如果你在JSP中用out.flush不但但會沖掉你自己的output,還會導致之前所有的<DOCTYPE...><html><head>...這些都被沖掉，如此會使JSP缺少很多output，所輸出網頁就非常不完整。所以catalina不允許你這么做。

⑧ java.util.concurrent.forkjoinpool 在哪個包

ArrayListList實現, 態數組式實現數組自擴展, java.util包 ArrayList貌似沒類,都List類.