我有一个RX生成器,它创建一个像这样的字符串流(真实流的简化版本):
A1 A2 A3 B1 B2 C1 C2 C3 C4 C5 C6....
流是无穷无尽的,但有序.因此,在以A用完为止的字符串之后,B启动.当B用完,C开始......当Z用完了,我们转移到AA1等有数目不详A的,B的等,但它通常每个字母10-30实例.
我正在寻找一种方法将这个流划分为所有A的块:A1 A2 A3,所有B:B1 B2所有C:C1 C2 C3 C4 C5 C6等等.每个块可以是一个可观察的(我将变成一个列表)或只是一个列表.
我使用RxJava尝试了几种不同的方法,所有方法都失败了.其中不起作用的是:
分组依据:由于流是无穷无尽的,因此每个字母的可观察量不会完成.所以当A的用完和B的开始时,A的Observable没有完成.因此,可观察量越来越多.
具有distinctUntilChanged的窗口/缓冲区 - 我在原始流上使用"distinctUntilChanged"来输出每个组的第一个项目(第一个A,第一个B等).然后我使用该流作为输入window或"缓冲"运算符用作窗口/缓冲区之间的边界.这不起作用,我得到的只是空列表.
什么是使用RX的正确解决方案？我更喜欢Java解决方案,但是其他RX实现中可以轻松转换为Java的解决方案也非常受欢迎.
在Java的内存模型保证了之前发生的对象的构造和释放的关系:
从对象的构造函数的末尾到该对象的终结器(第12.6节)的开始有一个发生前的边缘.
以及最终字段的构造函数和初始化:
当构造函数完成时,对象被认为是完全初始化的.在该对象完全初始化之后只能看到对象引用的线程可以保证看到该对象的最终字段的正确初始化值.
还有一个关于volatile字段的保证,因为关于对这些字段的所有访问的关系都存在:
写入易失性字段(第8.3.1.4节) - 在每次后续读取该字段之前发生.
但是常规的,古老的非易失性领域呢？我已经看到很多多线程代码在使用非易失性字段构造对象后不会创建任何类型的内存屏障.但是我从来没有见过或听说过任何问题,而且我自己也无法重建这种局部结构.
现代JVM在施工后是否只是放置了内存屏障？避免在施工周围重新排序？还是我很幸运？如果是后者,是否可以编写可以随意重现部分构造的代码？
编辑:
澄清一下,我说的是以下情况.假设我们有一个班级:
public class Foo{
public int bar = 0;
public Foo(){
this.bar = 5;
}
...
}
一些Thread T1实例化一个新Foo实例:
Foo myFoo = new Foo();
然后将实例传递给其他线程,我们将调用它T2:
Thread t = new Thread(() -> {
if (myFoo.bar == 5){
....
}
});
t.start();
T1 进行了两次我们感兴趣的写作:
bar了新实例化的值5myFoomyFoo变量对于T1,我们得到写#1 发生的保证- 在写#2 之前:
线程中的每个动作都发生 …
我们正在使用不同规模的Azure SQL数据库对我们的应用程序进行基准测试,并且我们很难使数据库饱和.除此之外,我们已经执行了这个查询:
SELECT *
FROM sys.dm_os_wait_stats
ORDER BY wait_time_ms DESC
结果的第一行是类似的
wait_type waiting_tasks_count wait_time_ms max_wait_time_ms signal_wait_time_ms
VDI_CLIENT_OTHER 19560 409007428 60016 37281
这等待时间是几号？在409000秒(差不多5天)内,我们到底在等什么呢？谷歌似乎不知道是什么VDI_CLIENT_OTHER.
我的代码看起来像这样:
char * decode_input(char ch)
{
switch(ch) {
case 'g':
return "get";
break;
case KEY_F(9):
return "quit";
break;
default:
return "unknown";
break;
}
}
有线索吗？
我有以下问题:
我有一个可观察的东西正在做一些工作,但是其他的可观察者需要那个observable的输出才能工作.我试图在同一个observable上多次订阅,但在日志中我看到原始的observable被多次启动.
多数民众赞成我的observable创建对象:
Observable.create((Observable.OnSubscribe<Api>) subscriber -> {
if (mApi == null) {
//do some work
}
subscriber.onNext(mApi);
subscriber.unsubscribe();
})
这就是我需要对象的可观察性
loadApi().flatMap(api -> api....()));
我正在使用
.subscribeOn(Schedulers.io()) observable.observeOn(AndroidSchedulers.mainThread())
.unsubscribeOn(Schedulers.io()
在所有可观察的.
我正在使用 jgit (version 4.8.0.201706111038-r) 将git repo 克隆到临时目录中，并添加关闭挂钩以在终止后删除临时目录。但是，关闭挂钩无法从.git子目录中删除某些文件（尽管关闭了 jgit 要求的 Git 对象）。
有趣的是，只有当我使用 Path API ( Files.delete(<PATH>)) 时删除才会失败，但如果我使用旧的file.delete().
这是一个最小的独立示例，其唯一依赖项是 jgit 4.8.0.201706111038-r：
public static void main(String... args) throws Exception {
String gitRepo = "https://github.com/netgloo/spring-boot-samples.git";
Path localDir = Files.createTempDirectory(null);
// Clone repo
Git git = Git.cloneRepository().setURI(gitRepo).setBranch("master").setDirectory(localDir.toFile()).call();
// Print some stuff to make sure that the git repo actually works
for (RevCommit c : git.log().call()) {
System.out.println(c);
}
git.getRepository().close(); // Close all the things!
git.close(); // Close all …成功发送和接收来自多个对等方的握手后,BitTorrent消息链中的下一步是位域消息.
所述位字段消息看起来像下面,其中,所述顶行explainins协议段的字节长度:
<4-bytes><1-byte><x-bytes>
<nrOfBits><identifier><bits>
我遇到的问题是,几乎所有同行似乎都在发送与上述表示不同的位域消息!消息往往看起来像这样:
size: 332, [0, 0, 0, 112, 5, 127, -1, -1, -1, -1, -5, -1, -1, -1, -1, -1, -17...]
第一个问题是我收到的大多数消息都有长度字节:
[0, 0, 0, 112]
即使在这种情况下接收的消息总共包含332个字节,而在某些其他情况下,消息可能只有80个字节左右.
第二个问题是这些位通常是重复-1或其他一些奇怪的负值.
我不认为这可归因于我身边的低级编码问题,因为其他消息工作正常.
有多个代码示例假定以下指令(1)和(2)不能重新排序：
int value;
volatile boolean ready;
// ...
value = 1; // (1)
ready = true; // (2)
后一个 Stack Overflow 答案是指 JLS §17.4.5：
如果 x 和 y 是同一线程的动作，并且 x 在程序顺序中排在 y 之前，则 hb(x, y)。
但是我不明白为什么这应该适用于这里，因为 JLS示例 17.4-1还指出：
[...] 允许编译器重新排序任一线程中的指令，前提是这不会影响该线程的单独执行。
这显然是这里的情况。
JLS 中特定于的所有其他定义volatile仅针对相同的 volatile 变量，而不针对其他操作：
对 volatile 字段（第 8.3.1.4 节）的写入发生在该字段的每次后续读取之前。
在人们看到 volatile （读或写）的使用可能不会重新排序的保证时，我感到困惑。
您能否将您的解释基于 JLS 或基于 JLS 的其他来源。
该泊坞窗，撰写文档指出：
cpu_count , cpu_percent, cpu_shares, cpu_period, cpu_quota, cpus , cpuset, 域名, 主机名, ipc, mac_address, mem_limit, memswap_limit, mem_swappiness, mem_reservation, oom_kill_disable, oom_score_adj, user_score_only, work_score_only, Privileged_m
这些中的每一个都是一个值，类似于它的 docker run 对应项。
但是docker run 他们参考的文档只提到了cpus. 没有提到cpu_count：
--cpus=0.000 CPU 数量。Number 是一个小数。0.000 表示没有限制。
那么有什么作用cpu_count呢？
以下代码是线程安全的吗？如果是这样，什么保证将ByteBuffer实例安全发布到执行 的线程CompletionHandler？
AsynchronousSocketChannel channel = ...
ByteBuffer buf = ByteBuffer.allocate(1024);
channel.read(buf, null, new CompletionHandler<Integer, Void>() {
//"completed" can be executed by a different thread than channel.read()
public void completed(Integer result, Void attachment) {
buf.flip(); //Can buf be safely accessed here? If so, why?
//...
}
public void failed(Throwable exc, Void attachment) {
//...
}
});