标签: concurrency

AtomicBoolean做什么,一个volatile布尔无法实现？

我搜索过Swift书,但找不到Swift版本的@synchronized.如何在Swift中进行互斥？

我相信Erlang社区并不羡慕Node.js,因为它本身可以进行非阻塞I/O,并且可以轻松地将部署扩展到多个处理器(甚至没有内置在Node.js中).有关详情,请访问http://journal.dedasys.com/2010/04/29/erlang-vs-node-js和Node.js或Erlang

那么Haskell呢？Haskell能否提供Node.js的一些好处,即一个干净的解决方案,以避免在不使用多线程编程的情况下阻止I/O？

Node.js有很多吸引人的东西

1. 事件:没有线程操作,程序员只提供回调(如在Snap框架中)
2. 保证回调在单个线程中运行:不存在竞争条件.
3. 简单易用的UNIX友好API.好处:优秀的HTTP支持.DNS也可用.
4. 默认情况下,每个I/O都是异步的.这样可以更容易地避免锁定.但是,回调中过多的CPU处理会影响其他连接(在这种情况下,任务应分成较小的子任务并重新调度).
5. 客户端和服务器端的语言相同.(但是我没有看到这个值太多了.jQuery和Node.js共享事件编程模型,但其余部分非常不同.我只是看不出服务器端和客户端之间的共享代码如何在实践中很有用.)
6. 所有这些都包装在一个产品中.

我如何使用AtomicBoolean以及该类的用途是什么？

我有点理解AtomicInteger和其他Atomic变量允许并发访问.在什么情况下这个类通常使用？

假设我们有这两个Runnables:

class R1 implements Runnable {
    public void run() { … }
    …
}

class R2 implements Runnable {
    public void run() { … }
    …
}

那么这有什么区别:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();

    r1.run();
    r2.run();
}

还有这个:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);

    t1.start();
    t2.start();
}

今天我实验室的敏感操作完全错了.电子显微镜上的执行器越过它的边界,在一系列事件之后,我损失了1200万美元的设备.我已将故障模块中的40K以上线路缩小到:

import java.util.*;

class A {
    static Point currentPos = new Point(1,2);
    static class Point {
        int x;
        int y;
        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    public static void main(String[] args) {
        new Thread() {
            void f(Point p) {
                synchronized(this) {}
                if (p.x+1 != p.y) {
                    System.out.println(p.x+" "+p.y);
                    System.exit(1);
                }
            }
            @Override
            public void run() {
                while (currentPos == null);
                while (true)
                    f(currentPos);
            }
        }.start();
        while (true)
            currentPos = new Point(currentPos.x+1, currentPos.y+1);
    } …

我试图理解破坏者的模式.我看过InfoQ视频,试图阅读他们的论文.我知道有一个环形缓冲区,它被初始化为一个非常大的数组,以利用缓存局部性,消除新内存的分配.

听起来有一个或多个原子整数可以跟踪位置.每个"事件"似乎都得到一个唯一的id,它在环中的位置是通过找到与模数相关的模数等来找到的.

不幸的是,我没有直观的感觉它是如何工作的.我做了很多交易应用程序并研究了演员模型,看过SEDA等.

在他们的演讲中他们提到这种模式基本上是路由器的工作方式; 但是我还没有找到路由器如何工作的任何好的描述.

是否有一些更好解释的好指示？

这是对Java中常见并发问题的一种调查.一个例子可能是经典的死锁或竞争条件,或者可能是Swing中的EDT线程错误.我对各种可能的问题既感兴趣,也对最常见的问题感兴趣.因此,请在每条评论中留下Java并发错误的一个特定答案,如果您看到自己遇到的错误,请立即投票.

Java教程说创建一个Thread很昂贵.但为什么它很贵？创建Java Thread会使其创建成本高昂时究竟发生了什么？我认为这句话是正确的,但我只是对JVM中线程创建的机制感兴趣.

线程生命周期开销.线程创建和拆解不是免费的.实际开销因平台而异,但线程创建需要时间,将延迟引入请求处理,并且需要JVM和OS的一些处理活动.如果请求频繁且轻量级,就像在大多数服务器应用程序中一样,为每个请求创建新线程会占用大量计算资源.

来自Java Concurrency in Practice
作者:Brian Goetz,Tim Peierls,Joshua Bloch,Joseph Bowbeer,David Holmes,Doug Lea
打印ISBN-10:0-321-34960-1