Ⅰ 首都北京的虚拟货币大咖们都看好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);
}
}
}