f*****w
发帖数: 2602 | 1 看了文档和尝试了一些简单例子之后有些基本了解了。目前的理解是每个功能的模块都
应该是一个verticle，但是具体操作的building block应该都是Handler。 但是基于这
个理解又有些疑问
第一个问题是 文档里面说而一个module 里面实际上可以有多个verticle，并且互相
之间可以通信。但是文档里面对于如何同时启动多个verticle或者如何对于verticle寻
址通信只字未提。 是还有什么其他文档我没有看到吗 还是说verticle和handler是两
个完全可以互相取代的概念，所有对handler可以做的操作同样也可以对verticle操作？
第二个问题是 我不明白系统什么时候做并行操作。比如 我在同一个verticle里面监听
了10个端口，每个不同的端口是个不同的REST服务。这种情况下是不是意味着这10个服
务完全就没有可能被并行了 （因为每个verticle都是单线程的）。那这也就意味着对
于REST服务来讲，最优的做法应该是每个服务都运行自己独立的verticle ？ 我这麽想
对吗 |
|
z****e
发帖数: 54598 | 2 container.deployVerticle("foo.ChildVerticle", new AsyncResultHandler
() {
public void handle(AsyncResult asyncResult) {
if (asyncResult.succeeded()) {
System.out.println("The verticle has been deployed, deployment
ID is " + asyncResult.result());
} else {
asyncResult.cause().printStackTrace();
}
}
});
你说的是这种吧？
这个其实不是，verticle的名字放在第一个参数里面，也就是那个foo.ChildVerticle
这个才是verticle，后面那个handler是异步时候需要做的，其实就是一个lambda
文档为了向后兼容，所以用老的方式写，... 阅读全帖 |
|
z****e
发帖数: 54598 | 3 之所以这么做
是因为你启动的是一个main函数
which一定会挂靠在某一个verticle下
你也知道，一个process只能启动一个main啊
你不能启动多个main吧？
对吧？无论啥语言，都只能有一个main入口，一个process的话
但是你写的verticle每个都有一个main
那你不可能用命令行把他们挨个启动，那样就成multi process了
我们要做的是multi thread，而非process
所以把deployverticle的东西用程序语言来实现，这里其实我用的是python
然后你启动了这个verticle之后，这个verticle会依次去部署那些verticles
酱紫同一个process其实运行多个threads，which不需要你操心的
如果你启动了多个process的话，之间的协调是很蛋疼的一件事
vert.x把thread的communication都做好了，有bus
如果是单线程的process，启动多个的话，你要自己去找bus，然后安装
调试，测试，一堆事，烦死
至于handler，这个是程序员的一个约定俗成的名称
一般涌来搞一个具体的eve... 阅读全帖 |
|
z****e
发帖数: 54598 | 4 系统什么时候并行你不需要操心
反正你的每一个verticle对象只会被一个thread所执行，在同一个时间点内
不会互相干扰，所以你不用去管vert.x什么时候做并行操作，什么时候不做
这个dispatch由vert.x来搞
所以哪怕你启动的只有一个verticle，只监听一个port
也还是会有多个threads来调用这个verticle的instances，java里面就是内存对象
然后当并发量大的时候，thread就会多起来
然后不同的threads如果调用同一个verticle
那么他们会分别持有这个verticle的不同instances
每一个thread分配一个instance酱紫
你就当你写的verticle是运行在单线程环境中就好了，并行的事，vert.x会帮你搞定
当然一个重要前提就是，你不能直接share object between threads
如果需要在不同threads中分享数据，则你需要看用bus
另外我记得他们好像提供了一个内存共享的map好像，你要自己查查 |
|
z****e
发帖数: 54598 | 5 verticle是抽象的概念，module是具体的文件
verticle是每次运行的时候，vert.x保证每一个verticle的instance会被单个thread所
访问
不会被多个thread同时访问，而module是你把文件打成的包叫做module
所以可以把多个verticle放到同一个module下面去
但是vert.x运行的时候，还是会将每一个verticle的instance安排给一个具体的thread
vert.x默认是你有多少个core，就运行多少个threads
这样你就不需要像node一样启动多个process了
这些threads之间的通信通过bus来通信 |
|
f*****w
发帖数: 2602 | 6 非常感谢这麽详细地解释了这些概念 我再消化一下 ：－）
那第一个问题呢？ 我对handler 和 verticle 之间的关系也很困惑。原因是因为我在
试图自己弄个toy example，里面主verticle会去deploy多个子verticle。 文档讲得很
模糊，我自己找到的API是 container.depolyVerticle（） 但是这个函数take的
类型居然是handler! 这样让我不太明白我在根据需求设计自己的verticle／handler的
时候应该让他们遵从什么原则 |
|
z****e
发帖数: 54598 | 7 vert.x其实就是object或者说是verticle层面的封装
这样你就不用像fp一样搞什么immutable了
轻松容易许多，当然你要搞也可以，只是木有必要
记住这句话
"Vert.x guarantees that a particular verticle instance is never executed by
more than one thread concurrently."
http://vertx.io/manual.html#concurrency |
|
z****e
发帖数: 54598 | 8 举个例子
class A
A有个对象是a
如果你啥都没做的话
那么这个a并不是线程安全的
为了线程安全，人们想出了各种方法
比如一种线程安全的机制就是lock
但是lock会带来各种狗血问题，比如死锁
而另外一种机制就是immutable
每个thread访问时候，拷贝一份副本就是了
但是这也会带来各种问题，而且不利于理解
fp的狂徒居然发疯了一样要求人们接受什么都是常量的想法
神经病
然后spring什么则是不做控制，你自己要留意
这样就加重了你写代码时候的负担，等于什么都没有做
然后node干脆就干掉多线程，用单线程来做
多线程启动多个process，但是这样的话
你自己要去管理process，以发挥最大机能
尤其是多个cpu多个core的环境下，也麻烦
然后ejb说我可以保证每个instance，一次只会被一个thread所访问
就木有问题，但是这样并发量大的时候，有些操作会导致thread堵塞
就是同步操作，所以ejb并没有很好滴address大并发的问题
虽然提出的构想和目标很美好，但是实现的手段不够好
很多人还是选择了spring那些
但是有了异步之后，大量block的操作... 阅读全帖 |
|
z****e
发帖数: 54598 | 9 会blocked，交给worker verticle就好了 |
|
z****e
发帖数: 54598 | 10 是的，你的理解非常准确
其实所有的多线程框架都提供了一种机制解决冲突问题
因为lock&synchronised的确是很难搞
让用户不再需要去写这些东西是这些框架的目的
vert.x除了worker以外的verticle都是异步的，或者说都需要做成异步的
同步会block线程
ejb当初设计时候没有考虑到异步的情况
因为毕竟年代已经有些久远了，所以大多数操作都还是同步的
但是以后不知道，以后这个情况可能会发生改变
另外一个request未必对应一个thread，看设计
到了具体的instance，可能是多个对应一个，或者一个request调用多个instance
但是在同一个时间点内，一个线程只会调用一个instance
保证其他threads不会过来搞
异步的设计跟同步的架构设计有明显区别，同步是一个request启动一个thread
但是异步不是，异步是有多少个cpu的core，启动多少个thread
然后把event pool里面的events分配给这些threads
这个是vert.x，node是只有一个thread去轮询event pool
所以会启动多process，其他框... 阅读全帖 |
|
t**r
发帖数: 3428 | 11 vert.x 就那么点东西：verticles, event bus. http server/client, tcp server/
client
没了。
真的很好学。
到底有多有用，还在摸索 |
|
t**r
发帖数: 3428 | 12 vert.x 就那么点东西：verticles, event bus. http server/client, tcp server/
client
没了。
真的很好学。
到底有多有用，还在摸索 |
|
z****e
发帖数: 54598 | 13 会依次对比node.js, fp, spring, ejb和vert.x的解决方案，然后自己看哪个最好
从最基本的说起，所有语言都一定会有两个东西
一个是变量，我们用var(variable)来表示
另外一个是方法/函数，用func(function)表示
假设有一个函数和一个变量
var var1;
func func1(){
var1 = 0;
return var1+1;//应该是1
}
那现在如果有多个线程并发
那结果会怎样？
那在func1执行完var1 = 0;之后
就有可能有其他线程插入，把var1改成其他值
比如改成var1 = 2; 或者var1 = "goodbug乱入";
那瞬间func1返回值不再是1了，那这个显然是不可接受的
那怎么办？
第一种是fp的做法，fp说，把变量做成immutable
也就是var -> val(value)，把var1改成
val1 = 0;
return val1+1;//就一定是1鸟
但是这样为了多线程把所有的参数都搞成immutable鸟
然后你写代码时候，需要时刻提醒自己
常量啊，常量啊，常量啊……
第二种是node.js等... 阅读全帖 |
|
z****e
发帖数: 54598 | 14 会依次对比node.js, fp, spring, ejb和vert.x的解决方案，然后自己看哪个最好
从最基本的说起，所有语言都一定会有两个东西
一个是变量，我们用var(variable)来表示
另外一个是方法/函数，用func(function)表示
假设有一个函数和一个变量
var var1;
func func1(){
var1 = 0;
return var1+1;//应该是1
}
那现在如果有多个线程并发
那结果会怎样？
那在func1执行完var1 = 0;之后
就有可能有其他线程插入，把var1改成其他值
比如改成var1 = 2; 或者var1 = "goodbug乱入";
那瞬间func1返回值不再是1了，那这个显然是不可接受的
那怎么办？
第一种是fp的做法，fp说，把变量做成immutable
也就是var -> val(value)，把var1改成
val1 = 0;
return val1+1;//就一定是1鸟
但是这样为了多线程把所有的参数都搞成immutable鸟
然后你写代码时候，需要时刻提醒自己
常量啊，常量啊，常量啊……
第二种是node.js等... 阅读全帖 |
|
z****e
发帖数: 54598 | 15
assigned
vertx
差不多是这样滴
by default，vert.x会启动多个threads，根据你具体的cores来建
但是，一个verticle，只能被一个thread执行，在同一个时间点
所以如果你只写了一个verticle，然后启动vert.x去用这个verticle去listen某一个
port
那么虽然vert.x启动了多个threads，但是这个verticle只能被一个thread所执行
所以瓶颈就发生在这里，因为一个thread独占了这个verticle，其他threads就只能干
瞪眼了
也做不了什么事，所以这个时候，需要直接scale out，根据core数量
部署相同数量的verticles，这样多个threads就可以同时listen同一个port了
这个在v3文档中有很清晰的描写
DeploymentOptions options = new DeploymentOptions().setInstances(16);
vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle", o... 阅读全帖 |
|
z****e
发帖数: 54598 | 16 把文档好好看看吧
v3还提供了一种简化的直接在代码里面嵌入blocking code的方式
虽然会使得代码马上变丑陋，但是便于测试
但是不管怎样，区分blocking和non blocking code应该是第一步
一般web都是non blocking伺候http req
拿到blocking的req的话，就交给worker
当然你也可以直接用worker伺候http req，但是这种用得比较少
所以你可以简单认为worker是处于一般verticle后面一个level的verticle也就是actor
v3新加入了一个Multi-threaded worker verticles
这个要用起来的话，可以节省verticle的数量，可以复用func/methods这些
但是需要用到多线程的技巧，一般都用在worker之后用来复用method/func的wrapper用
类似spring和fp的1st class func的搞法
你可以简单认为这个verticle是处于worker之后一个level的verticle
这样三层应该够你用了，你非要弄4-5层，那实在没有办法一一对应
毕竟... 阅读全帖 |
|
z****e
发帖数: 54598 | 17 新特性里面最典型的一条就是不再要求用户打成zip包了
直接.js, .class, .groovy, .ruby什么就可以install了
以前vert.x 2时代需要打成mod，写一个mod.json，然后install
这样做略微繁琐了点，以后不用了，直接verticle的源代码就可以直接安装并运行了
以前2时代虽然也可以，但是不推荐这么使用
vert.x的verticle跟akka的actor是一个idea，就是actor模型
另外一个改变就是减少对ide的依赖
所有的hello world例子里面，都可以直接从main函数启动vert.x
这样在ide中run的时候就不再需要额外的plugin支持
直接就可以右键点击，选择run application，就可以run了
以前跟eclipse集成略显麻烦，需要找到vert.x自身的main函数
然后怎样怎样，以后不用了，甚至你可以自己用java命令行运行
第三个就是vert.x可以直接打成fat jar包并export
这样你在任何一个有jdk的地方都可以直接运行
不再需要修改path，设置vertx home这些
第四个新增mu... 阅读全帖 |
|
z*******3
发帖数: 13709 | 18 写一个verticle，用来对付mail，你的逻辑都在这里面
需要同时对付大并发，你就直接部署多个这样的verticles就好了
然后逻辑完成之后，异步发送json给另外一个verticle
这个verticle就是你的streaming verticle，用rxjava
用来统计a = b+c这些计算
json就是你的msg，就是最后一个结果的msg/json
这样都在同一个虚拟机内完成，就是纯粹的内存计算
就可以直接规避redis,akka,node这些集成带来的不同层之间的io操作 |
|
x***4
发帖数: 1815 | 19 今天早上看了一下vertx。根据zhaoce的思路讲讲：
by default, 每个vertx instance （注意不是verticle）是multithread的. thread的
数目等于core的数目。 每条thread运行一个独立的event loop。
verticle instance（类似actor）被建立之后，会被assigned到其中一个event loop（
也就是一条thread）。vertx保证这一个verticle instance的code都一定会在assigned
的event loop（thread）上运行（除非你自己在verticle里开新的thread）。所以就不
存在race condition；什么synchronized, volatile, AtomicInteger之类的都可以扔
掉了。
至于jxcore的benchmark，我感觉是他只deploy了一个verticle instance，所以vertx
的几条thread中只有一条在运行，其他的都没事干，实际上变成了单线程。
这个理解对不对？
port |
|
h*******0
发帖数: 270 | 20 用vertx和play都没错。
用worker verticle没什么毛病啊。 你要理解vertx和play的概念其实都是差不多的。
verticle其实就是actor啊。 用这种框架要考虑好业务逻辑。这样就不存在蛋疼了啊。
你的aws client就是client，和vertx没什么联系。 用vertx实现好你的业务逻辑，各
个verticle关系弄好就行。 用worker verticle来调用你的aws client。 play也是同
理。 actor本身也支持async 和sync两种。 所以用哪个都行。。
我原来公司用的是play 大约3million req/min。 所以handle10k/s不是问题。
其实你就算用spring也可以做到这个量级。 但是新的框架对于non blocking io的支持
会好些，scale方面会好些， 也会节约成本。 |
|
z****e
发帖数: 54598 | 21 akka最头疼的就是树状结构
到最后actors越来越多，自己都有些迷失了
虽然理论上可以复用actor，但是大部分时候都是各自写各自的
vert.x就是扁平的网状结构，每一个verticle都是平等的
随时可以通过verticles的组合来形成你的需求处理链
而且msg的发送是通过bus来发送的，不像actor那样，跟每个actor绑定
这就增加了代码的复用的可能性，而且akka一旦有一个actor挂了
整个处理逻辑就over了，但是vert.x可以随时拔插进verticles，就比较方便 |
|
z****e
发帖数: 54598 | 22 vert.x的blocking部分找worker
这个跟node是一样的
worker负责blocking部分的代码
non blocking和blocking部分分离
你一开始就需要区分这两者
一般的verticle是non blocking的
如果有顺序要求，上worker verticle
如果顺序需要跨越verticles的话，需要用上rxjava
以及subscribe/publish pattern
否则会造出金字塔来 |
|
z****e
发帖数: 54598 | 23 As long as u start the shell verticle
u can list all verticles running
and manually deploy/undeploy verticles
and also send a msg to eventbus
etc.
http://vertx.io/docs/vertx-shell/java/ |
|
z****e
发帖数: 54598 | 24
immutable还是有用的，verticle之间需要immutable，用cglib做immutable object
type无所谓，用verticle封死就无所谓到底是static还是dynamic，就那点代码，随便玩
然后coroutine/async/await
实践中，对于java程序猿，没有接触过其他环境的java程序猿，纯后端出身的程序猿
我们一般建议先从groovy开始接触其他环境，一般半个小时后就能开始写了
动态类型并没有什么问题，前提是写verticle，然后元数据编程很好用
一个@immutable就能作出immutable了，都不需要自己倒腾cglib了，虽然cglib也不难
如果是以前做安卓的，则建议从kotlin开始接触其他环境
最近idea社区版支持scala啦，开始逐步接触尝试尝试
同时建议写点ruby啊什么的，来锻炼一下脚本的语法糖，蛮好玩的
目标成就：vert.x上全语言制霸 |
|
g*****9
发帖数: 4125 | 25 Your problem is door jamb is not perfectly verticle or door hinge is not
straight.
Use a long level and some shim should be able to fix it.
If you have not done this before, take your time, do not rush.
Shim the jamb to be perfectly verticle first (z axis)
Second make sure, all 3 hinges are in a straight line (z axis is not bowed)
Your door should be able to stop at any position after that. |
|
g*****9
发帖数: 4125 | 26 Your problem is door jamb is not perfectly verticle or door hinge is not
straight.
Use a long level and some shim should be able to fix it.
If you have not done this before, take your time, do not rush.
Shim the jamb to be perfectly verticle first (z axis)
Second make sure, all 3 hinges are in a straight line (z axis is not bowed)
Your door should be able to stop at any position after that. |
|
s*****l
发帖数: 321 | 27 All I can find in your quoted message is about 'changing from verticle to
horizontal', but nothing about by PD.
By the way, the change from verticle to horizontal SO benefited thousands of
EB2C (of cource, even more EB2I).
Then |
|
z****e
发帖数: 54598 | 28 没错，要两个web server，一个给java，一个给python
然后各自包装成一个web service，然后再用第三个来call
很折腾，vert.x直接把两个给弄成verticles也就是modules
然后你自己再写一个主体的verticle用event bus去communicate
这样一个web server就可以
JAVA) |
|
m*******t
发帖数: 1060 | 29 要不然是坏境问题，要不然是。。。。深表同情。 对了，刚刚试了一下vert,x, 先在
linux上，然后在windows上，都没有你说的问题。 呵呵。
Update: There IS a problem when running vert.x java code. Sounds like
whenever launching /windows/system32/java.exe, this app tries to read the
jre settings
configured through "Java Configuration Applet"(under control pannel). From
there, it knows which java is active. However, I failed to use this applet
to configure java to use JDK instead of jre.
On linux, /usr/bin/java is a symbolic link to the actual jre/jdk, so it ... 阅读全帖 |
|
l*******o
发帖数: 250 | 30 not every time, but happened several times at least. Only got issues with
this site.
C:\dev\vert.x>gvim bin\vertx.bat
C:\dev\vert.x>vertx run Server.java
"C:\Java\jdk1.7.0_45/bin/java.exe" -Djava.util.logging.config.file="c:\
dev\vert.x\bin\..\conf\logging.properties" -Dvertx.home="c:\dev\
vert.x\bin\.." -Dvertx.clusterManagerFactory="org.vertx.java.spi.cluster.
impl.hazelcast.HazelcastClusterManagerFactory" -classpath ";c:\dev\
vert.x\bin\..\conf;c:\dev\vert.x\bin\..\lib\*" org.vertx.java.... 阅读全帖 |
|
z*******3
发帖数: 13709 | 31 组件pool最大的好处就在于复用这部分代码
spring通过给不同thread提供可以被分享的func来减少内存的使用
这部分说起来挺麻烦，跟fp的immutable有点类似
简单说就是spring也主张要无副作用的func
不要在func外寄存状态，只有ejb和vert.x可以在func外寄存状态
vert.x也只有worker和普通的verticle可以寄存
新增加的multiple thread shared verticle就跟spring很像了
都不允许寄存状态，如果不寄存状态的话，每个func所属的object
只需要实例化一次就可以了，ejb就会实例化一堆，然后pool起来
spring对于一般的bean只实例化一个，并不断复用这一个
spring也提供那种可以寄存状态的，需要设置bean为prototype
这样每次调用都会重新生成一个object，只是不推荐你这么搞 |
|
z****e
发帖数: 54598 | 32
好像不需要，如果我理解的long polling没有错的话
akka因为都拆成了actor了，所以转换成node很容易
vert.x也是一样的，verticle是最小单位，然后根据verticle转换就好了 |
|
z****e
发帖数: 54598 | 33 linus骂的java是98年时候的事情了
那时候还在applet，win98就有jvm和applet
类似的jobs骂的java也都是根据applet得出的经验
这两个人说的java基本上没啥意义
另外xml对于一些简单的config比json更为简洁
对比
{
verticle:{
name: "com.abc.mypkg",
instances: 10
}
}
和
n行和1行的区别 |
|
p*****2
发帖数: 21240 | 34 zhaoce，你做的app里有多少worker verticles？都是干什么的？
有多少regular verticles？都是干什么的？ |
|
z*******3
发帖数: 13709 | 35
用vert.x就可以做到real time咯
不需要用到跨tiers的io
直接用vert.x自带的bus就可以发送消息了
然后其他逻辑几乎可以照抄你说的所有逻辑
做一个verticle来取代node
再做另外一个verticle来取代akka
ok啦
vert.x就是强大，看懂了vert.x，这些东西都是小意思 |
|
z****e
发帖数: 54598 | 36 verticle之间一般不share data
如果需要share data，则需要通过msg bus来完成
先将需要share的data转换成json，然后发送给其他的verticle
因为json是所有语言都能接受的这么一个数据格式
那json自然就是immutable的，在发送和接收过程中是无法被更改的
好吧，至少msg bus不会尝试去更改msg，这样就不需要lock了
原理跟fp的多线程原理是一样的
但是vert.x很巧妙滴用这种方式，绕开了immutable这个概念
你不知不觉中就用了fp的多线程的那种方式，就是actor model
但是这种方式呢，有些人会说，太麻烦
ok，那就用map这些来分享data
那这个时候就需要做成immutable的object了
因为actor model之间的share datas必需是immutable的
否则会破坏single threadness
但是这个技能有些高级，一般人可以不用
如果需要用的话，这个就很容易理解
另外，vert.x的lock也有，是Cluster-wide locks
不是threads之间share data... 阅读全帖 |
|
|
z****e
发帖数: 54598 | 38 http://github.com/vert-x3/vertx-examples/tree/master/spring-exa
This project is a demo of exposing Spring-hosted service beans (and
therefore Spring-wired services) via vert.x verticles. In vert.x 3 it’s
perfectly possible to share an application context between multiple
verticles.
In this case the service bean we expose through vert.x is a trivial data
access service running through Spring Data JPA (and using Hibernate). In
effect we’re taking advantage of the ease of building data access via
S... 阅读全帖 |
|
z****e
发帖数: 54598 | 39
vert.x把这些概念全部屏蔽了
现在连dont block me这一条黄金准则都被vertx sync给干掉了
以后你写商业逻辑，只需要估算一下
如果执行时间久的话，放一个annotation
@Suspendable上去，thread就会自动切换component/verticle
不需要操心了，如果不知道到底执行多久
对于所有的verticle里面的方法，全部放@Suspendable |
|
z****e
发帖数: 54598 | 40
你是不是在琢磨如何用android上的app冲event bus直接塞msg？
不要这么搞，event bus的api还没有公开
好像用的是web socket，也就是thin http1.1协议
你要连的话，建一个udp的verticle，然后listen到某一个port上去就好了
eventbus留给verticle之间内部使用
另外，因为是同一台jvm，所以你可以直接用shared map这些
直接共享数据，跟msg类似，都要immutable才行
用string就是了 |
|
l**********n
发帖数: 8443 | 41 linux下thread和process没太大区别，vrrt.x has so called worker thread. I
assume your python code is run in a worker thread . it is also called
verticle. you can think of verticle like an actor |
|
p******u
发帖数: 14642 | 42 有些硬件是摆在那的，米国当年射土星的时候在啃泥地太空中心建了个verticle
assembly building。尺寸多大忘了也懒得去狗，反正贼大贼大的，能形成室内天气系
统。我朝要有奔月的野心就肯定也会在文昌建个相当的建筑，可问题是现在没半点风声
机。 |
|
z****e
发帖数: 54598 | 43
计算机语言其实很简单啊
就是把机器能够理解的各种指令，翻译成人能够理解的语言
最早无非01010000111这些，然后有了汇编，就是指令集嘛
但是看指令多累啊，所以有了操作系统unix和c
但是操作系统和c主要是解决cpu的问题
对于cpu基本上封装得差不多了，但是对于内存呢
c封装得不彻底，就是人还是要手工去操作内存，释放内存这些
很烦，而且容易错，但是在c那个年代，没有特别好的方法
然后c++加入了点object的概念，因为在c横行的那个年代
软件系统已经开始越做越大了，而因为c对于内存的操作没有做封装和统一管理
导致很多项目因为程序员对内存的操作不当，而失败
当时的数据是90%以上大型项目是失败的
包括james gosling本人做的那个c++项目
搞不定，疯了，于是sun那批人就凑一起，说，我们来设计一种新的语言
以解决这些常见的问题，然后就有了java和jvm
jvm其实就是操作系统的扩展，无非就是做了几件所有项目都会遇到的问题
一个是跨平台，把所有操作系统无差别对待，让软件摆脱对于操作系统的依赖
程序员可以不在乎什么操作系统，你可以在unix上编译，然后放到window... 阅读全帖 |
|
z****e
发帖数: 54598 | 44
你不可能要求7k理解了所有知识点之后才开工
那拿的就不是7k了，而是1w2w了
我设计的框架就是直接从.java -> verticle
测试通过后马上上投产无问题
如果这套机制实现不了，那是我的问题 |
|
z****e
发帖数: 54598 | 45 matlab就是一个脚本
你来说说，对于16个core的cpu，你该如何充分发挥其性能？
脚本除了忽悠点数学理论外，屁都做不出来
你再说说，因为分布式必然接触网络
所谓网络就是连接神经元的神经系统
java写个internet socket分分钟搞定
你用c写，写到明天能搞定不？还别错
你用脚本？除了http req/resp以外，你还能干嘛？
来，写个udp server试试，看你出不出问题
最像神经系统的就是vert.x的eventbus
简直就是神经系统的直接模拟，而每一个verticle就像是一个神经树突
整个vert.x在单机上就像是一个神经元
懂了没？这就是一个人的大脑的雏形了 |
|
n****e
发帖数: 109 | 46 Packaging Design Structural Engineer
GC or citizenship required
contact me at j**********[email protected]
The Packaging Engineer is directly responsible for the structural and
creative design, development
and cost analysis of innovative protective packaging products to meet
customers’ needs. Works
closely with company’s and customers’ engineering, production, and
purchasing departments to
determine costs and feasibility of producing proposed packaging, with a
particular emphasis on
structural integr... 阅读全帖 |
|
n****e
发帖数: 109 | 47 可能需要绿卡，worth a try anyway
pm我拿邮箱，我帮忙转发简历给HR
Job description
Mechanical Packaging Design Engineer
This is a full time, permanent position. We, do, however have an immediate
need before we make the final hiring decision, so if you would like to help
out in a contract capacity, please state such in your application or via
cover letter.
The Mechanical Engineer is directly responsible for the structural and
creative design, development and cost analysis of innovative protective
packaging products t... 阅读全帖 |
|
n****e
发帖数: 109 | 48 Green Card or US citizenship is required.
Contact me at : [email protected]
/* */
The Technical Project Manager is directly responsible for the structural and
creative design, development
and cost analysis of innovative protective packaging products to meet
customers’ needs. Works
closely with company’s and customers’ engineering, production, and
purchasing departments to
determine costs and feasibility of producing proposed packaging, with a
particular emphasis on
structural integri... 阅读全帖 |
|
z*******3
发帖数: 13709 | 49
actor是erlang, akka的东西，他说复杂了
你要是有兴趣，看看akka,vert.x这些就知道了，vert.x里面的verticle就是actor
server挂了之后，问问能不能启新的node，假设你用的是cloud
如果可以的话，新的node需要从persistence中读出之前的数据来
所以用redis就比较合理，因为redis可以做到persistence
如果是纯内存计算的server的话，就不行了
或者前面说的，多个设备之间自己做一个copy
第一次登陆了之后，server把多个设备的信息反馈给每一个client
然后每一个client本地做备份，然后就可以不用经过server了
就像qq聊天，大多数时候都是client -> client
但是你也可以选择client -> server -> client |
|
z*******c
发帖数: 39 | 50 厚颜来板上请教大神，假设并发要求大概在10k/s 而且大量用到AWS service， 在考虑
到开发成本和实际的deliverable timeline前提下，你们会怎么选择？考古了一下
mitbbs以前的帖子 看起来不看好vertx的人不少 觉得vertx是未来趋势的也有
AWS官方的sdk都是blocking的 用vert.x就必须要用execute blocking或者用worker
verticle， 感觉都很蛋疼，然后本身vertx future的chaining我感觉也并没有非常好用
play的前后版本不兼容让我非常倒胃口，然而performance benchmark上排名靠前而且
用java没有什么学习曲线，组里本来就主要用java
公司庙小，总想着快速迭代出成果，目前感觉vertx的学习曲线让组里的人有点蛋疼
已经不知道该怎么问了，也许另辟蹊径用falcon？
无奈了。。。 |
|
