Ⅰ 首都北京的虛擬貨幣大咖們都看好borderless無界幣未來的升值空間，對此各位圈內朋友有何見解
1. Borderless系統的技術支持
1) 高效且可擴展性能
Borderless系統實現超 10 萬次/s批量轉賬
高性能的區塊鏈技術對加密貨幣和智能合約平台來說是必須的，能夠為業界提供一個有可能代替現有金融平台的解決方案。為了能夠實現比VISA和MasterCard每秒可以處理交易數量更快的速度，無界從底層開始重新設計。通過股份授權證明機制，無界網路可以在平均一秒的時間內確認超 10 萬次轉賬交易。
Borderless系統架構總覽
要達到行業裡面最頂級的性能，無界借鑒LMAX交易所的經驗。這個 LMAX 交易所可以在每秒內處理高達 6 百萬次的交易。無界借鑒其技術的關鍵點，如下：
a) 將一切東西放在內存裡面
b) 將核心的業務邏輯放到一個單線程裡面
c) 將加密演算法操作(哈希和簽名)放在核心業務邏輯以外
d) 將校驗的操作分成狀態獨立和狀態依賴檢查
e) 使用一種面向對象的數據模型
通過遵守這些簡單的規則，無界在未進行顛覆式優化工作的情況下，實現了每秒處理 10 萬次轉賬的高效性能。如果有進一步的優化工作的話，會讓無界可以達到與 LMAX 交易所相近的性能表現(即每秒 600 萬次)。需要注意到，無界達到這樣的性能表現是高度依賴其中的一個兼容交易協議。如果想用業務邏輯運行在一個進行加密演算法操作和用哈希識別器去調用所有對象的虛擬機上的話，不可能達到同樣層級的性能表現。區塊鏈天生就是單線程的，而單核的 CPU 的性能是各種資源中最短缺的、最難擴展的一個方面。 無界的技術邏輯能夠讓這個單線程的執行達到極可能的高效。
Borderless系統核心業務背書
區塊鏈是一個下達關於確定去修改一個共享的全局狀態交易的全球賬本。這些交易中包含的命令可以改變其他交易的有效性。例如，你不能在你的支票存入生效前，從你的銀行賬戶里支取金額。在能夠影響一個特定的賬戶的所有先前交易都被處理之前，你不可能知道一個交易是否有效。 如果兩個無關聯的賬號沒有共享任何通用的依賴關系的話，理論上這兩個賬號的交易可以是在同一時間進行處理的。實際上，在一個由具備仲裁條件的智能合 約驅動的賬本上識別哪些交易是真正獨立存在的耗費是很棘手的。唯一的保證兩個交易是真正獨立存在的方法，是通過維護完全分離的賬本，然後定期在它們之間傳輸價值。如果要用這種性能表現的權衡關系去打比方的話，可以像是非一致內存訪問架構(Non-Uniform Memory Access ，NUMA)和一致內存訪 問架構(Uniform Memory Access ，UMA)之間的關系。 實際上，一致內存訪問架構對開發者來說是更容易去設計的，而且耗費更低。非一致內存訪問架構通常是在建造超級計算機和大型計算機集群時作為不得已的方法去採用的。 計算機產業逐漸意識到通過平行計算去實現性能的擴張並沒有早期那麼容易，畢竟那時候最需要做的事情只是提高處理器的頻率而已。就是因為這個原因，處理器的設計者們在嘗試去採用多線程設去提高性能之前都在拚命去提高單線程的性能。當多線程還不夠的話，而且只有這樣的話，集群計算這個方案才會被考慮。
很多加密貨幣產業的人在沒有探索過在技術上一台電腦的單個核心能實現什麼之前，就嘗試通過用集群計算的方案去解決可擴展性的問題。
2) LMAX Disruptor 分解器技術
LMAX 分解器提供了一個在單線程上可以實現什麼表現的學習例子。LMAX 是一個針對終端顧客的交易平台，目標是成為世界上最快的交易所。它們一直很慷 慨地將他們學到的東西公布出來。
LMAX架構的概要總覽：
業務邏輯處理器是所有順序交易和訂單匹配發生的地方。它是一個可以每秒處理百萬級別訂單的單線程。這個架構可以很容易地用在加密貨幣和區塊鏈設計的 領域。 輸入分解器扮演的角色是從很多來自不同源頭的用戶裡面收集訂單，然後分配給它們一個確定的順序。當給它們分配好順序後，它們會被復制、記錄然後廣播 到很多冗餘的業務邏輯處理器。輸入分解器是高度並行的，而且容易分包到一個計算機集群系統中。 當業務邏輯處理器處理完輸入後，一個輸出分解器負責通知那些關心結果的人。這也是一個高度並行的任務。 最終，通過在業務邏輯處理器里使用單線程樣品化處理器和 Java 虛擬機，LMAX 可以在每秒內執行 600 萬次交易。如果 LMAX 可以達到這個成績，那麼加密 貨幣和智能合約平台平不需要在每秒連 10 個交易都不到的情況下去考慮集群網路方案。 高性能區塊鏈
要建造一個高性能的區塊鏈，我們需要使用 LMAX 同樣的技術。這是幾個必須實現的事項: 將所有東西放在內存上，避免同步原語(鎖定，原子操作)，避免在業務邏輯處理器上不必要的計算。 由於內存的設計是高度並行的，因此越來越便宜。追蹤互聯網上每個人的賬戶余額和許可權所需要的數據量是可以放在小於 1TB 的 RAM 內存上，這用不到 15000 美元的價格就能買到了，而且可以裝在商品化(高端)的伺服器主板上。在這個系統被 30 億人採用之前，這類硬體會在普通的桌面計算機裡面看到。 真正的瓶頸不是內存容量的需求，而是帶寬的需求。在每秒 100 萬次交易和每筆交易占 256 位元組的情況下，網路會需要 256MB 每秒的數據量，即 1Gbit/s 的 帶寬。這樣的帶寬在普通的桌面計算機上並不是常見的。不過，這樣的帶寬只是二代互聯網 100Gbit/s 帶寬的一點而已。這個二代互聯網被供應給超過 210 個 美國教育機構、70 家公司和 45 個非盈利機構和政府機構。
另一句話說，區塊鏈技術可以輕松將所有東西保存在內存里，而且如果設計的合理的話可以擴展到支持每秒百萬級別的轉賬。
3) 分配ID並避免哈希計算
在單線程系統的系統裡面，處理器周期是需要被保留的稀缺資源。傳統的區塊鏈設計使用加密演算法基礎上的哈希計算去生成一個全球獨特的ID系統，以實現統計學上不會有碰撞的保證。進行這些哈希計算的問題是，它會耗用越來越多的內存和處理器周期。與一個直接的數組索引相比，這種方式會顯著地佔用更多處理器的時間去查找一個賬戶的記錄。例如，64位的整數對比和操作起來都要比160位以上的ID更簡單。更大的哈希ID機制意味著CPU緩存裡面的空間更少了，而需要更多的內存。在現代的操作系統里不常訪問的隨機存儲器是會被壓縮的，不過哈希識別器是隨機數，這是沒法壓縮的。型號區塊鏈給了我們一個在全球內分配獨特的ID的方法，這些ID互相之間不會起沖突，因此完全避免使用像比特幣地址那樣的哈希演算法為基礎的識別器去引用一個賬號、余額或者許可。
4) 從業務邏輯處理器中去除簽名校驗
所有在加密貨幣網路的交易依賴於用加密演算法簽名去校驗許可權。大部分情況下，請求的許可權可以由其他交易的結果改變。這意味著在業務邏輯處理器裡面，許可權需要被定義成與加密演算法計算無關的情況。
要達到這個目的，所有的公鑰需要分配一個獨特的和不可代替的ID。當ID被分配後，輸入分解器可以校驗提供的簽名與指定的ID是否匹配。當交易到達業務邏輯處理器後，只需要去檢查ID就可以了。
這個同樣的技術可以在擁有不可代替的靜態ID的對象上實現去除前提條件檢查。
5) 為靜態校驗設計交易
對交易來說，有很多特性是可以進行靜態檢查的，而不需要引用當前的全局狀態。這些檢查包括參數的范圍檢查、輸入的去冗餘和數組排序等。通常來說，有很多檢查是可以被進行的，如果交易包含它「假設」是全局狀態的數據的話。在這些檢查被執行後，業務邏輯處理器必須要做的事情就只有去確保這些假設還是正確的，這個過程總結下來就是檢查一個涉及交易簽名時間的對象引用的修改時間戳。
6) 智能合約
很多區塊鏈正在整合一種通用的腳本語言去定義所有的操作。這些設計最終將業務邏輯處理器定義為一個虛擬機，而所有的交易被定義為由這個虛擬機運行的腳本。這個方案有一個在真實處理器上的單線程性能極限，並且由於將所有東西強制通過一個虛擬處理器去執行，讓問題更嚴重了。一個虛擬處理器即使用上了實施編譯技術(JIT)也總會比一個真正的處理器要慢，不過計算速度並不是這種「任何東西都是一個腳本」方案的唯一問題。當交易被定義在這么低的層次上，意味著靜態檢查和加密演算法操作還是會被包含到業務邏輯處理的環節里，這也讓會讓整體的吞吐量降低。一個腳本引擎永遠不應該要求執行一個加密演算法簽名檢查的請求，即使這個請求是通過原生的機制實現的。
根據我們從LMAX上學到的課程，我們知道一個為區塊鏈設計的虛擬機應該考慮到單線程表現。這意味著在一開始就要為實施編譯優化，而且最常用的智能合約應該通過區塊鏈原生支持，而只有那些不常用的、定製的合約會運行在一個虛擬機上。這些定製的合約設計的時候要考慮性能，這意味著虛擬機應該將可以訪問的內存范圍限制到可以放在處理器緩存上的級別。
7) 面向對象的數據模式
在內存中保存所有東西的其中一個好處是，軟體可以設計成模仿現實世界中數據的關系。這意味著業務邏輯處理器可以迅速根據內存內的指針去找到數據，而不是被迫去進行耗費高的資料庫查詢任務。這意味著數據不需要復制就能訪問了，而且可以當場就被修改。這個優化提供了比任何資料庫為基礎的方案高一個數量級的性能表現。
Borderless無界系統的高效性能的成功創建，是建立在在核心業務邏輯上去除與關鍵性、訂單依賴性和評估無關的計算任務，並且設計一個可以幫助優化這些事項的協議。這就是無界做的事情。
borderless無界幣運營團隊及科技團隊均屬於全球頂級人才，擁有頂級技術和人才的團隊。borderless無界幣絕對擁有不可想像的巨大潛力，值得肯定。還在觀望么？機不可失失不再來，心動不如行動。
Ⅱ 如何讓Java以光的速度跨線程通信
一個比吞吐量等性能指標更好的框架，使用Railway演算法，將線程之間的消費發送參考現實生活中火車在站點之間搬運貨物。
目標起始於一個簡單的想法：創建一個開發人員友好的，簡單的，輕量級線程間的通信框架，無需使用任何鎖，同步器，信號量，等待，通知以及沒有隊列，消息，事件或任何其它並發特定的語法或工具。
只是一個Java介面接受到POJO以後在其背後實現這個通信，這個主意很類似Akka的Actors，但是它也許是有點矯枉過正，特別是對於單個多核計算機上線程間的通信優化必須是輕量的。
Akka的偉大之處是跨進程通信，特別是Actor是能夠跨越不同JVM節點實現分布式通信。
無論如何，你可能覺得使用Akka在一個小型項目上有些過度，因為你只需要線程之間的通信，但是你還是想使用類似Actor這種做法模式。
該文章作者使用了動態代理 堵塞隊列和一個緩存的線程池創建了這個解決方案，如圖：
SPSC隊列是一個Single Procer/Single Consumer 隊列(單生產者/單消費者)，而MPSC是一個Multi Procer/Single Consumer隊列。
Dispatcher線程從Actor線程接受到消息，然後發送到相應的SPSC中。
Actor線程從接受的消息中使用數據，調用相應的actor類的方法，Actor實例都是發送消息給MPSC隊列，然後再從Actor線程那裡得到消息。
下面是ping-pong案例：
public interface PlayerA (
void pong(long ball); //send and forget method call
}
public interface PlayerB {
void ping(PlayerA playerA, long ball); //send and forget method call
}
public class PlayerAImpl implements PlayerA {
@Override
@ublic void pong(long ball) {
}
}
public class PlayerBImpl implements PlayerB {
@Override
public void ping(PlayerA playerA, long ball) {
playerA.pong(ball);
}
}
public class PingPongExample {
public void testPingPong() {
// this manager hides the complexity of inter-thread communications
// and it takes control over actor proxies, actor implementations and threads
ActorManager manager = new ActorManager();
// registers actor implementations inside the manager
manager.registerImpl(PlayerAImpl.class);
manager.registerImpl(PlayerBImpl.class);
//Create actor proxies. Proxies convert method calls into internal messages
//which would be sent between threads to a specific actor instance.
PlayerA playerA = manager.createActor(PlayerA.class);
PlayerB playerB = manager.createActor(PlayerB.class);
for(int i = 0; i < 1000000; i++) {
playerB.ping(playerA, i);
}
}
這兩個play能夠每秒打500,000個乒乓。但是如果和單個線程執行速度相比，還是很差的，同樣代碼在單個線程可以到達每秒兩百萬個。
作者開始研究緩慢的原因，在一些校驗和測試以後，他認為是Actors之間發送消息影響了整體性能：
作者找到一個SPSC單生產者和單消費者的無鎖隊列，http://www.infoq.com/presentations/Lock-Free-Algorithms
無鎖隊列提供比鎖隊列更好的性能。鎖隊列中在當一個線程獲得鎖，其他線程將被阻塞，直到該鎖被釋放的。在無鎖演算法的情況下，生產者線程可以產生消息，但不阻止其他生產者線程，以及其他消費者，而從隊列中讀取的消費者不會被阻塞。
這個無鎖隊列據測試結果是超過每秒100M ops，是JDK的並發隊列實現的10倍。
但是作者使用這個無鎖隊列提到SPSC 以後，並沒有產生明顯性能提升，他立即意識到這個框架的性能瓶頸不是在SPSC，而是在多個生產者/單個消費者(MPSC)那裡。
多個生產者如果使用SPSC會覆蓋彼此的值，因為SPSC並沒有一個對生產者的控制機制，即使最快的SPSC也不適合。
對於MPSC作者找到了LMAX的disruptor，一個通過Ringbuffer實現的高性能線程間通信庫包。
使用Disruptor很容易實現非常低延遲，高吞吐量的線程間消息通信。它還提供了用例對生產者和消費者的不同組合。多個線程可以從環形緩沖區中讀取而不會阻塞對方：
多生產者和多消費者：
三個生產者/一個消費者測試結果顯示，Disruptor都是兩倍於LinkedBlockingQueue 。
但是使用Disruptor後的這個框架性能還是沒有達到預期，作者從上下班的地鐵中得到靈感，在某個站點同一車廂出來的人是生產者，進去的是消費者。
建立一個Railway類，使用AtomicLong來跟蹤地鐵在站與站之間的傳遞，下面是一個single-train railway:
public class RailWay {
private final Train train = new Train();
//站台號碼stationNo 跟蹤火車，定義哪個站點接受火車
private final AtomicInteger stationIndex = new AtomicInteger();
//多線程訪問這個方法，也就是在特定站點等待火車
public Train waitTrainOnStation(final int stationNo) {
while (stationIndex.get() % stationCount != stationNo) {
Thread.yield(); // this is necessary to keep a high throughput of message passing.
//But it eats CPU cycles while waiting for a train
}
// the busy loop returns only when the station number will match
// stationIndex.get() % stationCount condition
return train;
}
//這個方法通過增加火車站台號將火車移到下一個站點。 public void sendTrain() {
stationIndex.getAndIncrement();
}
}
參考Disruptor，創建線程間傳遞long值：
public class Train {
//
public static int CAPACITY = 2*1024;
private final long[] goodsArray; // array to transfer freight goods
private int index;
public Train() {
goodsArray = new long[CAPACITY];
}
public int goodsCount() { // returns the count of goods
return index;
}
public void addGoods(long i) { // adds item to the train
goodsArray[index++] = i;
}
public long getGoods(int i) { //removes the item from the train
index--;
return goodsArray[i];
}
}
如下圖兩個線程傳遞long：
使用一列火車實現單個生產者單個消費者：
public void testRailWay() {
final Railway railway = new Railway();
final long n = 20000000000l;
//starting a consumer thread
new Thread() {
long lastValue = 0;
@Override
public void run() {
while (lastValue < n) {
Train train = railway.waitTrainOnStation(1); //waits for the train at the station #1
int count = train.goodsCount();
for (int i = 0; i < count; i++) {
lastValue = train.getGoods(i); // unload goods
}
railway.sendTrain(); //sends the current train to the first station.
}
}
}.start();
final long start = System.nanoTime();
long i = 0;
while (i < n) {
Train train = railway.waitTrainOnStation(0); // waits for the train on the station #0
int capacity = train.getCapacity();
for (int j = 0; j < capacity; j++) {
train.addGoods((int)i++); // adds goods to the train
}
railway.sendTrain();
if (i % 100000000 == 0) { //measures the performance per each 100M items
final long ration = System.nanoTime() - start;|
final long ops = (i * 1000L * 1000L * 1000L) / ration;
System.out.format("ops/sec = %,d\n", ops);
System.out.format("trains/sec = %,d\n", ops / Train.CAPACITY);
System.out.format("latency nanos = %.3f%n\n",
ration / (float)(i) * (float) Train.CAPACITY);
}
}
}
Ⅲ 電腦上那麼多應用程序，基本上都不能用Java做出來，為什麼Java還是最有前途的東西
當你在安裝Java在你的桌面時會得到答案，或者Oracle會告訴你超過了30億的設備正在運行著Java！大多數大公版司都以權不同的方式運用著Java。許多伺服器程序都是拿 Java 來編寫以處理每天超過數以千萬的數據，網路上的交易系統也是拿 Java 編寫例如LMAX交易平台系統，其覆蓋內部路徑的阻斷式的內部通信線程Disruptor。在itjob的官網里，我們會看到許多更貼切的例子，哪些項目是在Java的基礎上完成的，哪些領域和部門在運用Java？
Ⅳ borderless無界幣的區塊鏈是否處於世界頂端科技與其他虛擬貨幣相比，優勢是否比較明顯
1. Borderless系統的技術支持
1) 高效且可擴展性能
Borderless系統實現超 10 萬次/s批量轉賬
高性能的區塊鏈技術對加密貨幣和智能合約平台來說是必須的，能夠為業界提供一個有可能代替現有金融平台的解決方案。為了能夠實現比VISA和MasterCard每秒可以處理交易數量更快的速度，無界從底層開始重新設計。通過股份授權證明機制，無界網路可以在平均一秒的時間內確認超 10 萬次轉賬交易。
Borderless系統架構總覽
要達到行業裡面最頂級的性能，無界借鑒LMAX交易所的經驗。這個 LMAX 交易所可以在每秒內處理高達 6 百萬次的交易。無界借鑒其技術的關鍵點，如下：
a) 將一切東西放在內存裡面
b) 將核心的業務邏輯放到一個單線程裡面
c) 將加密演算法操作(哈希和簽名)放在核心業務邏輯以外
d) 將校驗的操作分成狀態獨立和狀態依賴檢查
e) 使用一種面向對象的數據模型
通過遵守這些簡單的規則，無界在未進行顛覆式優化工作的情況下，實現了每秒處理 10 萬次轉賬的高效性能。如果有進一步的優化工作的話，會讓無界可以達到與 LMAX 交易所相近的性能表現(即每秒 600 萬次)。需要注意到，無界達到這樣的性能表現是高度依賴其中的一個兼容交易協議。如果想用業務邏輯運行在一個進行加密演算法操作和用哈希識別器去調用所有對象的虛擬機上的話，不可能達到同樣層級的性能表現。區塊鏈天生就是單線程的，而單核的 CPU 的性能是各種資源中最短缺的、最難擴展的一個方面。 無界的技術邏輯能夠讓這個單線程的執行達到極可能的高效。
Borderless系統核心業務背書
區塊鏈是一個下達關於確定去修改一個共享的全局狀態交易的全球賬本。這些交易中包含的命令可以改變其他交易的有效性。例如，你不能在你的支票存入生效前，從你的銀行賬戶里支取金額。在能夠影響一個特定的賬戶的所有先前交易都被處理之前，你不可能知道一個交易是否有效。 如果兩個無關聯的賬號沒有共享任何通用的依賴關系的話，理論上這兩個賬號的交易可以是在同一時間進行處理的。實際上，在一個由具備仲裁條件的智能合 約驅動的賬本上識別哪些交易是真正獨立存在的耗費是很棘手的。唯一的保證兩個交易是真正獨立存在的方法，是通過維護完全分離的賬本，然後定期在它們之間傳輸價值。如果要用這種性能表現的權衡關系去打比方的話，可以像是非一致內存訪問架構(Non-Uniform Memory Access ，NUMA)和一致內存訪 問架構(Uniform Memory Access ，UMA)之間的關系。 實際上，一致內存訪問架構對開發者來說是更容易去設計的，而且耗費更低。非一致內存訪問架構通常是在建造超級計算機和大型計算機集群時作為不得已的方法去採用的。 計算機產業逐漸意識到通過平行計算去實現性能的擴張並沒有早期那麼容易，畢竟那時候最需要做的事情只是提高處理器的頻率而已。就是因為這個原因，處理器的設計者們在嘗試去採用多線程設去提高性能之前都在拚命去提高單線程的性能。當多線程還不夠的話，而且只有這樣的話，集群計算這個方案才會被考慮。
很多加密貨幣產業的人在沒有探索過在技術上一台電腦的單個核心能實現什麼之前，就嘗試通過用集群計算的方案去解決可擴展性的問題。
2) LMAX Disruptor 分解器技術
LMAX 分解器提供了一個在單線程上可以實現什麼表現的學習例子。LMAX 是一個針對終端顧客的交易平台，目標是成為世界上最快的交易所。它們一直很慷 慨地將他們學到的東西公布出來。
LMAX架構的概要總覽：
業務邏輯處理器是所有順序交易和訂單匹配發生的地方。它是一個可以每秒處理百萬級別訂單的單線程。這個架構可以很容易地用在加密貨幣和區塊鏈設計的 領域。 輸入分解器扮演的角色是從很多來自不同源頭的用戶裡面收集訂單，然後分配給它們一個確定的順序。當給它們分配好順序後，它們會被復制、記錄然後廣播 到很多冗餘的業務邏輯處理器。輸入分解器是高度並行的，而且容易分包到一個計算機集群系統中。 當業務邏輯處理器處理完輸入後，一個輸出分解器負責通知那些關心結果的人。這也是一個高度並行的任務。 最終，通過在業務邏輯處理器里使用單線程樣品化處理器和 Java 虛擬機，LMAX 可以在每秒內執行 600 萬次交易。如果 LMAX 可以達到這個成績，那麼加密 貨幣和智能合約平台平不需要在每秒連 10 個交易都不到的情況下去考慮集群網路方案。 高性能區塊鏈
要建造一個高性能的區塊鏈，我們需要使用 LMAX 同樣的技術。這是幾個必須實現的事項: 將所有東西放在內存上，避免同步原語(鎖定，原子操作)，避免在業務邏輯處理器上不必要的計算。 由於內存的設計是高度並行的，因此越來越便宜。追蹤互聯網上每個人的賬戶余額和許可權所需要的數據量是可以放在小於 1TB 的 RAM 內存上，這用不到 15000 美元的價格就能買到了，而且可以裝在商品化(高端)的伺服器主板上。在這個系統被 30 億人採用之前，這類硬體會在普通的桌面計算機裡面看到。 真正的瓶頸不是內存容量的需求，而是帶寬的需求。在每秒 100 萬次交易和每筆交易占 256 位元組的情況下，網路會需要 256MB 每秒的數據量，即 1Gbit/s 的 帶寬。這樣的帶寬在普通的桌面計算機上並不是常見的。不過，這樣的帶寬只是二代互聯網 100Gbit/s 帶寬的一點而已。這個二代互聯網被供應給超過 210 個 美國教育機構、70 家公司和 45 個非盈利機構和政府機構。
另一句話說，區塊鏈技術可以輕松將所有東西保存在內存里，而且如果設計的合理的話可以擴展到支持每秒百萬級別的轉賬。
3) 分配ID並避免哈希計算
在單線程系統的系統裡面，處理器周期是需要被保留的稀缺資源。傳統的區塊鏈設計使用加密演算法基礎上的哈希計算去生成一個全球獨特的ID系統，以實現統計學上不會有碰撞的保證。進行這些哈希計算的問題是，它會耗用越來越多的內存和處理器周期。與一個直接的數組索引相比，這種方式會顯著地佔用更多處理器的時間去查找一個賬戶的記錄。例如，64位的整數對比和操作起來都要比160位以上的ID更簡單。更大的哈希ID機制意味著CPU緩存裡面的空間更少了，而需要更多的內存。在現代的操作系統里不常訪問的隨機存儲器是會被壓縮的，不過哈希識別器是隨機數，這是沒法壓縮的。型號區塊鏈給了我們一個在全球內分配獨特的ID的方法，這些ID互相之間不會起沖突，因此完全避免使用像比特幣地址那樣的哈希演算法為基礎的識別器去引用一個賬號、余額或者許可。
4) 從業務邏輯處理器中去除簽名校驗
所有在加密貨幣網路的交易依賴於用加密演算法簽名去校驗許可權。大部分情況下，請求的許可權可以由其他交易的結果改變。這意味著在業務邏輯處理器裡面，許可權需要被定義成與加密演算法計算無關的情況。
要達到這個目的，所有的公鑰需要分配一個獨特的和不可代替的ID。當ID被分配後，輸入分解器可以校驗提供的簽名與指定的ID是否匹配。當交易到達業務邏輯處理器後，只需要去檢查ID就可以了。
這個同樣的技術可以在擁有不可代替的靜態ID的對象上實現去除前提條件檢查。
5) 為靜態校驗設計交易
對交易來說，有很多特性是可以進行靜態檢查的，而不需要引用當前的全局狀態。這些檢查包括參數的范圍檢查、輸入的去冗餘和數組排序等。通常來說，有很多檢查是可以被進行的，如果交易包含它「假設」是全局狀態的數據的話。在這些檢查被執行後，業務邏輯處理器必須要做的事情就只有去確保這些假設還是正確的，這個過程總結下來就是檢查一個涉及交易簽名時間的對象引用的修改時間戳。
6) 智能合約
很多區塊鏈正在整合一種通用的腳本語言去定義所有的操作。這些設計最終將業務邏輯處理器定義為一個虛擬機，而所有的交易被定義為由這個虛擬機運行的腳本。這個方案有一個在真實處理器上的單線程性能極限，並且由於將所有東西強制通過一個虛擬處理器去執行，讓問題更嚴重了。一個虛擬處理器即使用上了實施編譯技術(JIT)也總會比一個真正的處理器要慢，不過計算速度並不是這種「任何東西都是一個腳本」方案的唯一問題。當交易被定義在這么低的層次上，意味著靜態檢查和加密演算法操作還是會被包含到業務邏輯處理的環節里，這也讓會讓整體的吞吐量降低。一個腳本引擎永遠不應該要求執行一個加密演算法簽名檢查的請求，即使這個請求是通過原生的機制實現的。
根據我們從LMAX上學到的課程，我們知道一個為區塊鏈設計的虛擬機應該考慮到單線程表現。這意味著在一開始就要為實施編譯優化，而且最常用的智能合約應該通過區塊鏈原生支持，而只有那些不常用的、定製的合約會運行在一個虛擬機上。這些定製的合約設計的時候要考慮性能，這意味著虛擬機應該將可以訪問的內存范圍限制到可以放在處理器緩存上的級別。
7) 面向對象的數據模式
在內存中保存所有東西的其中一個好處是，軟體可以設計成模仿現實世界中數據的關系。這意味著業務邏輯處理器可以迅速根據內存內的指針去找到數據，而不是被迫去進行耗費高的資料庫查詢任務。這意味著數據不需要復制就能訪問了，而且可以當場就被修改。這個優化提供了比任何資料庫為基礎的方案高一個數量級的性能表現。
Borderless無界系統的高效性能的成功創建，是建立在在核心業務邏輯上去除與關鍵性、訂單依賴性和評估無關的計算任務，並且設計一個可以幫助優化這些事項的協議。這就是無界做的事情。
現在市場98%的虛擬貨幣是無法達到borderless無界幣區塊鏈技術，優勢十分顯著。
Ⅳ Java 世界有哪些優秀的第三方開源 jar 包值得推薦使用
幾個常用的吧。
工具類：
1. log4j
理由：向system.out.println()說永別，剛開始學java的時候總是喜歡依靠system.out.println()的輸出來查看異常和調試。後來工作後就果斷log4j了，這樣項目開發和發布的時候，可以根據自己的需求開關日誌級別，把日誌列印到遠程服務等多種功能。現在這個基本成為標配了。
2.guava
google出品的第三方工具庫。當java.util 提供的數據結構不能滿足的時候從這里你可以快速找到大量已經寫好的數據結構了，這使得你不用花費心思在一些常用的數據結構上了。比如LRU緩存之類的。只是好幾個版本的跨度比較大，兼容也不怎麼好。
3.apache commons 包含的組件 http://commons.apache.org/。
apache commons 涵蓋了大量的小工具，比如發郵件(線上告警用)，快速且方便的IO操作封裝。等等工具很多，可以自己慢慢去學習。
4.netty
一個網路通信框架,當需要實現自定義協議的時候我就用這個，netty的新版本自帶了很多協議的實現版本，這是搞網路快速開發不二的選擇。
5.httpclient 系列
主要是用在測試線上服務的時候用的。畢竟是一個基於http協議網路工具，當開發的web上線的時候，利用httpclient來寫測試用例，效果很不錯。測試的工具有很多，但是這個可以滿足你定製http請求的需求。
服務類：
1.jetty
httpclient 的同一個項目下有一個簡易的http server 但是沒有實現servlet，這個時候jetty的效果就體現出來了。特別的是，當你打算對 jsp jstl 等方式編寫的網頁進行功能測試的時候，jetty就可以承擔 mock的作用，好用得很。使得你可以在junit的框架下對jsp編寫的網頁進行測試。
2.maven
現在的java已經離不開這個玩意了。你可以自己搭建一個nexus 來做maven私服。當你存在RPC的需求的時候。完全可以把自己的介面部分和client打包上傳到maven私服，調用的服務只需要include這個包就可以遠程調用你的服務了。在國內配合上bbo這類 SOA框架。那個效果酸爽的很。完成了實際意義上的介面於實現在網路層級的分離。讓java 的package 形成一個網路上的package。需要某個服務的時候，include 直接調用。其他的一律不用管。
先那麼多，後續再補
=======================補充分割線
1. Disruptor http://lmax-exchange.github.io/disruptor/
高性能的並發框架，一般用來在涉及到 生產者--消費者模型的時候會用到。拋開性能不談(實際上性能相當棒)它的抽象方式和介面都設計得很好。
2.quartz http://www.quartz-scheler.org/
一個調度器，當涉及到多任務定時調用的時候這個框架能幫上非常多。特別在網路游戲伺服器中，如果需要定時或者短時定時來做某些事情的時候（用戶的長時間buff狀態，刷新時間等），quart是一個非常不錯的選擇。如果時間比較短的話，利用java內置的DelayQueue 也可以。
Ⅵ LMAX的Disruptor如何工作(stackoverflow的回答)
它可以用來替代隊列，同時有很多SEDA和Actors模式的特性。 和隊列比較： Disruptor可以向其他線程發送消息，並在需要的時候喚醒其他線程（和BlockingQueue相似）。不過，他們之間有三個主要的區別。 2. 把消息放入Disruptor需要2個步驟，首先在ring buffer中聲名一個介面，這個介面提供使用者一個可以存放正確數據的Entry。然後必須提交這個entry，要想像上文提到的那樣靈活使用內存，這兩個步驟是必需的。提交操作使得消費者線程可以讀取消息。 3. ring buffer中被消費的消息應該由消費者來追蹤。不讓ring buffer來追蹤消息可以減少寫沖突的出現，因為每個線程都自己維護計數器。 與Actors比較 Actor模型是最接近Disruptor的程序模型，尤其是使用BatchConsumer/BatchHandler類。這些類隱藏了所有保持已消費的序列號的復雜實現的並且在重要事情發生的時候會提供一些簡單的回調方法。不過有兩個小小的區別。 1. Disruptor使用一個線程對應一個消費者的模型，而Actors使用多對多的模型，比如你可以擁有盡可能多的actor，它們會分布在一定數量的線程上（一般一個核心一個actor）。 2. BatchHandler介面提供了一個額外的（而且是很重要的）回調方法onEndOfBatch().它允許耗時操作，比如將I/O操作放到批處理中一起執行以提高吞吐量。使用其他Actor框架也可以作批處理，但是它們幾乎都沒有提供批處理執行結束的回調方法，你只能使用超時來判斷批處理是否結束，從而導致差的延時。 和SEDA比較LMAX設計Disruptor模式是為了替代SEDA。 1. 和SEDA相比，disruptor主要的改進就是可以並行工作。Disruptor支持組播消息來實現這個功能，相同的消息（以一致的順序）被發送給多個消費者。這樣可以避免在管道中交叉層。 2. 消費者可以依賴其他消費者的處理結果，通過把一個隊列化的層放在它們之間。一個消費者可以簡單地看到自己所依賴的消費者的序列號。這樣可以避免在管道中合並層。 和內存障比較 可以把dispruptor理解為一個結構化的，有序的內存障。其中生產者障礙相當於寫障礙，消費者障相當於讀障礙。 第二個回答（answered Jul 16 '11 at 5:48 irreputable）：首先我們來理解一下它提供的編程模型。 它有一個或多個作者和讀者。有一排從舊到新的條目（從左到右）。作者可以在右側新增條目。每個讀者按從左到右的順序讀取條目。讀者顯然不能跳過作者先讀取。 條目不能被刪除。我用「讀者」代替「消費者」來避免讓人以為條目會被消費掉。不過我們知道最後一個讀者左邊的條目是沒有用處的。 通常讀者可以並發地獨立地讀取條目。但是我們可以聲明讀者之間的依賴關系。讀者間可以有任意非環形依賴。如果讀者B依賴於讀者A，讀者B不能跳過讀者A先讀取。 讀者A可以註解一個條目，而讀者B依賴於這個註解，所以就有了讀者間的依賴。例如，A在一個條目上做一些計算，然後將結果保存到條目中的a欄位。然後A前進，之後B可以讀取這個條目和條目中的a。如果讀者C沒有依賴於A，那麼C就不應該讀取a。 當然了，LMAX的主要目標就是性能。Disruptor使用一個預分配的條目環。這個環足夠大，但是有上限，從而不會超出容量。如果環滿了，作者會一直等待，直到最慢的作者前進而騰出空間。 條目對象是預分配的並且會一直存在，以減少GC的消耗。我們不會增加新的條目對象或是刪除舊的，相反的，作者會請求一個已存在的條目，填充它的欄位，然後通知讀者。這兩個步驟真的是很簡單的原子操作。setNewEntry(EntryPopulator); interface EntryPopulator{ void populate(Entry existingEntry); }預分配的條目相當於adjacent memory cells中的adjacent entries分配(很像)，並且因為讀者是順序讀取條目，所以利用CPU緩存很重要。 還有做了很多努力來避免鎖，CAS，甚至是內存障（比如如果只有一個作者的話就使用不變的序列變數）。 寫給開發者：不同註解的讀者應該寫到條目中不同的欄位，從而避免寫沖突。（事實上他們應該寫在不同的緩存行中。
Ⅶ LMAX Disruptor是怎麼工作的
首先我們來懂得一下它供應的編程模子。LMAX的首要目的就是機能。Disruptor使用一個預分配的條目環。這個環足夠大，然則有上限，然後不會超出容量。若是環滿了，作者會一貫守候，直到最慢的作者提高而騰出空間。
它有一個或多個作者和讀者。有一排從舊到新的條目（從左到右）。作者可以在右側新增條目。每個讀者按從左到右的次第讀取條目。讀者明顯不能跳過作者先讀取。
我用「讀者」庖代「破費者」來防止讓人以為條目會被破費失落。但是我們曉得最終一個讀者左邊的條目是沒有用處的。
但凡讀者可以並發地自力地讀取條目。然則我們可以聲明讀者之間的依靠關系。讀者間可以有隨意率性非環形依靠。若是讀者B依靠於讀者A，讀者B不能跳過讀者A先讀取。
讀者A可以註解一個條目，而讀者B依靠於這個註解，所以就有了讀者間的依靠。例如，A在一個條目上做一些策畫，然後將效果保管到條目中的a欄位。然後A提高，之後B可以讀取這個條目和條目中的a。若是讀者C沒有依靠於A，那麼C就不應該讀取a。LMAX確實是一個風趣的編程模子。不論機能若何，單單這個模子就對使用很有好處。
維護破費者的最有用方法是國內的自在競爭和普遍全世界的自在商業。第一個回答
LMAX設計Disruptor
形式是為了互換SEDA。1.
破費者可以依靠其他破費者的處置責罰效果，經由進程把一個隊列化的層放在它們之間。一個破費者可以簡略地看到自身所依靠的破費者的序列號。多麼可以防止在管道中合並層。
2. 和SEDA比較，disruptor首要的改良就是可以並行任務。
LMAXDisruptor支撐組播音訊來完成這個功用，相同的音訊（以一致的次第）被發送給多個破費者。多麼可以防止在管道中穿插層。
Disruptor最簡略的描繪就是：它是線程間通訊最高效的體式花樣。它可以用來互換隊列，還有良多SEDA和Actors形式的特點。
和隊列斗勁：3.
Actor模子是最接近Disruptor的法度模子，尤其是使用BatchConsumer/BatchHandler類。這些類蔭蔽了一切僵持已破費的序列號的錯雜完成的而且在首要任務發生的時辰會供應一些簡略的回調方法。但是有兩個小小的差異。
2. 把音訊放入Disruptor需要2個步伐，首先在ring
buffer中聲明一個介面，這個接供詞給使用者一個可以寄存准確數據的Entry。然後必需提交這個entry，要想像上文提到的那樣靈敏使用內存，這兩個步伐是必需的。提交把持使得破費者線程可以讀作廢息。4.
LMAXDisruptor使用一個線程對應一個破費者的模子，而Actors使用多對多的模子，比方你可以擁有盡能夠多的actor，它們會散布在必定命量的線程上（普通一個中心一個actor）。5.
BatchHandler接供詞給了一個額定的（而且是很首要的）回調方法onEndOfBatch（）.它允許耗時把持，比方將I/O把持放到批處置責罰中一路實行以提高吞吐量。
Ⅷ java 並發框 架有 disruptor實例
http://hi..com/ogezkwhalp/item/56e5bf6475e5dc3cac3e83b1
LongEvent.java
publicclassLongEvent
{
privatelongvalue;
publicvoidset(longvalue)
{
this.value=value;
}
}
LongEventFactory.java
importcom.lmax.disruptor.EventFactory;
<LongEvent>
{
=newLongEventFactory();
publicLongEventnewInstance()
{
returnnewLongEvent();
}
}
LongEventHandler.java
importcom.lmax.disruptor.EventHandler;
<LongEvent>
{
publicvoidonEvent(LongEventevent,longsequence,booleanendOfBatch)
{
System.out.println("Event:"+event);
}
}
LongEventProcer.java
importjava.nio.ByteBuffer;
importcom.lmax.disruptor.RingBuffer;
publicclassLongEventProcer
{
privatefinalRingBuffer<LongEvent>ringBuffer;
publicLongEventProcer(RingBuffer<LongEvent>ringBuffer)
{
this.ringBuffer=ringBuffer;
}
publicvoidonData(ByteBufferbb)
{
longsequence=ringBuffer.next();//Grabthenextsequence
try
{
LongEventevent=ringBuffer.get(sequence);//GettheentryintheDisruptor
//forthesequence
event.set(bb.getLong(0));//Fillwithdata
}
finally
{
ringBuffer.publish(sequence);
}
}
}
LongEventMain.java
importjava.nio.ByteBuffer;
importjava.util.concurrent.Executor;
importjava.util.concurrent.Executors;
importcom.lmax.disruptor.RingBuffer;
importcom.lmax.disruptor.dsl.Disruptor;
publicclassLongEventMain
{
publicstaticvoidmain(String[]args)throwsException
{
//
Executorexecutor=Executors.newCachedThreadPool();
//Thefactoryfortheevent
LongEventFactoryfactory=newLongEventFactory();
//Specifythesizeoftheringbuffer,mustbepowerof2.
intbufferSize=1024;
//ConstructtheDisruptor
Disruptor<LongEvent>disruptor=newDisruptor(factory,bufferSize,executor);
disruptor.handleEventsWith(newLongEventHandler());
//StarttheDisruptor,startsallthreadsrunning
disruptor.start();
//.
RingBuffer<LongEvent>ringBuffer=disruptor.getRingBuffer();
LongEventProcerprocer=newLongEventProcer(ringBuffer);
ByteBufferbb=ByteBuffer.allocate(8);
for(longl=0;true;l++)
{
bb.putLong(0,l);
procer.onData(bb);
Thread.sleep(1000);
}
}
}