Tag: concurrency

ArrayBlockingQueue：并发put和take

为什么没有使用LinkedBlockingQueue的方式实现ABQ。 我们可以使用AtomicInteger来保持ABQ中的跟踪计数，也与LBQ一样。 我们也可以使用Two Locks for ABQ。 我偶然发现了关于SO的类似问题。 ArrayBlockingQueue使用单个锁进行插入和删除，但LinkedBlockingQueue使用2个单独的锁 但我无法理解这个问题的答案。 我需要帮助来理解如果我们使用两个锁实现ABQ会出现的问题。 如果有人可以举一个可能失败的竞争条件的例子，那将是非常好的。 这个问题可以标记为重复，但我真的在寻找更具描述性的答案。 那将是一个很大的帮助。 我在这里贴了一个代码http://pastebin.com/ZD1uFy7S 。 任何人都可以显示粘贴的代码中是否存在可能的竞争条件。

这里有并发问题吗？ 如何在开发过程中测试它？

场景：存在’n’个团队，每个团队都在他们的虚拟“墙”上工作（如facebook的墙）。 每个团队只看到自己的墙和上面的post。 这些post可以由post的作者或其他团队成员编辑（如果这样配置的话。假设确实如此，因为它必须具备）。 设计/技术决策：使用Restlet + Glassfish / Java + Mysql的RESTful Web应用程序（编辑：使用Apache DBUtils进行数据库访问。没有ORM – 似乎有点矫枉过正） 问题：多个团队登录T1，T2和T3（比如说），每个团队都有一些成员。 团队级数据访问存在并发性，但团队之间不存在并发性 – 即不同的团队访问不相交的数据集。 为了优化对DB的频繁读/写，我们正在考虑一个TeamGateway，它控制对DB的访问以处理并发。 Web服务器将缓存团队检索的数据以加快读取速度（并帮助更新墙上post列表） Q1：这是否需要（每个团队的TableGateway +缓存）？ 如果不是，您如何建议处理？ Q2：如果是这样，TableGateway（每个团队）是否需要编码为线程安全（同步方法）？ 假设我们有一个类/注册表TableGatewayFinder，它带有一个静态方法，返回TableGateway以用于该特定团队（使用hashmap）。 如果来自每个T1-T3登录的6个人那么只会创建3个TableGateways，它是否有助于捕获并发写入（提交之前的简单时间戳比较或“冲突标记”追加）并有效地管理缓存（我们计划拥有实体的身份映射 – 需要跟踪4-5个不同的实体.4个实体用于组合层次结构，另一个实体与4）中的每一个相关联？ 一个单元如何测试网关（基于TDD或事后）？ 提前致谢！

如何实现或找到线程安全的CompletionService的等价物？

我有一个在Tomcat容器中运行的简单Web服务，它本质上是multithreading的。 在进入服务的每个请求中，我想要对外部服务进行并发调用。 java.util.concurrent中的ExecutorCompletionService使我部分得到了。 我可以为它提供一个线程池，它将负责执行我的并发调用，当任何结果准备就绪时我会收到通知。 处理特定传入请求的代码可能如下所示： void handleRequest(Integer[] input) { // Submit tasks CompletionService completionService = new ExecutorCompletionService(Executors.newCachedThreadPool()); for (final Integer i : input) { completionService.submit(new Callable() { public Integer call() { return -1 * i; } }); } // Do other stuff… // Get task results try { for (int i = 0; i < […]

无法停止使用ExecutorService启动的任务

对不起，我必须打开一个新线程来描述这个问题。 今天早上我问了这个问题 ，有一些回复，但我的问题仍未解决。 这次我将附加一些可运行的代码（简化但有相同的问题），以便您重现问题： public class ThreadPoolTest { public static void main(String[] args) throws Exception { final ExecutorService taskExecutor = Executors.newFixedThreadPool(5); Future futures[] = new Future[5]; for (int i = 0; i < futures.length; ++i) futures[i] = startTask(taskExecutor); for (int i = 0; i < futures.length; ++i) System.out.println("futures[i].cancel(true): " + futures[i].cancel(true)); System.out.println("Cancel DONE."); taskExecutor.shutdown(); } […]

顺序一致性易变解释

我正在观看来自java jpoint会议的video。 我对来自Alexey Shipilev报告的幻灯片有疑问： 幻灯片上的非英语版请原谅。 实际上作者说变量集是不可能的 r1 = 1 (Y) r2 = 0 (x) r3 = 1 (x) r4 = 0 (Y) 根据video，他暗示这显然是。 根据JMM，有人可以澄清为什么这个价值设定不可能？ PS 如果我理解Alexey符号正确，则尊重以下代码： public class SequentialConsistency { static volatile int x; static volatile int y; public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { x = […]

Java Swing EDT和并发

我只是想知道是否仍然需要确保invokeLater（）Runnable的同步性。 我遇到了死锁，需要在保持并发性的同时克服它。 这是一个好代码的例子吗？： private String text; private void updateText() { SwingUtilities.invokeLater(new Runnable() { public void run() { synchronized(FrameImpl.this) { someLabel.setText(text); } } }); } 对于相当糟糕的示例感到抱歉，但我们必须假设text正被不同的线程修改，无法注入，并且依赖于正确的值。 这是正确的解决方案，还是通过将同步代码发送到未知的上下文中而无意中造成死锁问题？ 谢谢。

这段代码是线程安全的吗？

我想处理客户端请求流。 每个请求都有其特殊类型。 首先，我需要初始化该类型的一些数据，然后我可以开始处理请求。 当客户端类型第一次出现时，我只是初始化相应的数据。 在此之后，使用该数据处理该类型的所有以下请求。 我需要以线程安全的方式执行此操作。 这是我写的代码。 它是线程安全的吗？ public class Test { private static Map clientTypesInitiated = new ConcurrentHashMap(); /* to process client request we need to create corresponding client type data. on the first signal we create that data, on the second – we process the request*/ void onClientRequestReceived(int clientTypeIndex) { if (clientTypesInitiated.put(clientTypeIndex, “”) […]

在同一个try块中锁定多个ReentrantReadWriteLocks是否安全？

假设我有两个关键资源，foo和bar。 我用一些ReentrantReadWriteLock保护它们 ReentrantReadWriteLock foo = new RRWL() … ReentrantReadWriteLock bar = new RRWL() … 大多数操作只使用foo OR bar，但其中一些恰巧使用两者。 现在使用单个锁时，你不能只这样做： void foo() { foo.writeLock().lock(); privateWorkOnFoo(); foo.writeLock().unlock(); } 如果抛出exception，你的foo将永远被锁定。 相反，你包装它，就像 void foo() { try { foo.writeLock().lock(); privateWorkOnFoo(); } finally { foo.writeLock().unlock(); } } 但是，如果我需要同时工作呢？ 将它们放在一个块中是否安全？ 选项1 try { foo.writeLock().lock(); bar.writeLock().lock(); magic(); } finally { bar.writeLock().unlock(); foo.writeLock().unlock(); } 或者是否有必要为每个锁提供自己的块： […]

使用ConcurrentHashMap消除了数据可见性问题？

我已经阅读了Java Concurrency in Practice并留下了这个问题：当我使用ConcurrentHashMap时，本书第一部分讨论的数据并发问题我还需要担心吗？ 以下是我的一个程序中的几个示例： 1.交易者的当前位置 （共享整数，其中’整数’是数学术语） 此数字表示trader对象当前拥有的内容并定义其状态。 它必须阅读它的位置，知道该做什么（寻找开始一个新的位置，或管理当前的位置）。 Trader方法在自己的线程上运行。 broker对象负责设定trader者的头寸。 每当交易者的一个订单被填满时，它将设置头寸。 Broker方法在自己的线程上运行。 trader和broker都在同一个包裹中。 Position作为包私有static ConcurrentHashMap 。 键是交易者对象的id。 值为Integer。 包的外部是应用程序。 它通过公共吸气剂间接获得交易者的头寸。 职位每隔几分钟最多会改变一次，因此broker不会经常触摸地图。 但是， trader和应用程序将经常阅读。 此外，我们经常有几个交易者同时阅读地图。 那么以这种方式使用ConcurrentHashMap，我不必处理锁定和数据可见性问题？ ConcurrentHashMap可以处理所有事情吗？ 2.市场（买入价，卖出价，最后价格） 几乎与位置相同的情况，除了现在broker将非常频繁地更新价格（在繁忙时间每秒最多10次更新;通常是每秒几次）。 trader和应用程序仍然经常读取。 现在，地图键是指示哪个库存或未来的代码，以及值是保持市场价格的对象。 它似乎工作正常，但在阅读JCIP后，我意识到如果事情没有正确实现，程序仍然可以被破坏。 这本书讨论了ConcurrentHashMap，但没有明确告诉我第一部分我们不再需要手动解决的问题。 在这种情况下， 似乎我不必synchronize任何东西。 那是对的吗？

如何使用Reactor framework 2.x执行multithreading映射/减少？

我之前曾向Reactor 1.x提出这个问题 ： 假设我有一个Collection 。 我要： 将每个Map实例同时转换为Foo类型的对象（每个实例完全独立于另一个实例 – 不需要串行/迭代地转换每个实例）。 当所有这些都被转换时，我想要一个方法onReduce(Collection foos)被调用 – 该参数包含所有生成的Foo实例。 但我们似乎无法找到Reactor 2.x的等效解决方案 – 只需单线程。 你如何在Reactor 2.x中执行multithreadingmap / reduce？ 例如，如何使用基于ExecutorService的Dispatcher执行此操作？