javascript

java

python

c#

android

node.js

reactjs

c++

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

java-什么时候应该使用SynchronousQueu

new SynchronousQueue()
new LinkedBlockingQueue(1)

有什么区别? 什么时候应该使用SynchronousQueue和容量1的LinkedBlockingQueue

trans by 2020-01-19T01:27:58Z

为什么我需要std :: condition_variable?

我发现由于虚假唤醒,很难使用std::condition_variable。 所以有时候我需要设置一个标志,例如:

atomic<bool> is_ready;

我在致电notify(notify_one()notify_all())之前将condition_variable设置为true,然后等待:

some_condition_variable.wait(some_unique_lock, [&is_ready]{
    return bool(is_ready);
});

有什么理由我不应该这样做:(编辑:好,这确实是个坏主意。)

while(!is_ready) {
    this_thread::wait_for(some_duration); //Edit: changed from this_thread::yield();
}

如果condition_variable选择了等待时间(我不知道这是否成立),我宁愿自己选择。

trans by 2020-01-17T22:31:10Z

java-LinkedBlockingQueue的insert和remove方法线程安全吗?

我在两个不同的线程之间使用了add。 一个线程通过take添加数据,而另一个线程通过LinkedBlockingQueue接收数据。

我的问题是,我是否需要同步对add和2702441029218868861的访问。2702441029218868862的插入和删除方法线程安全吗?

trans by 2020-01-14T15:29:07Z

多线程-我们什么时候应该使用Java的Thread over Executor?

执行器似乎是干净的抽象。 您何时想直接使用Thread而不是依赖更强大的执行程序?

trans by 2020-01-14T12:57:27Z

C ++ 11中有并发容器吗?

特别是,我正在寻找阻塞队列。 C ++ 11中有这样的事情吗? 如果没有,我还有其他选择吗? 我真的不想自己回到线程级别。 太容易出错了。

trans by 2020-01-12T19:29:33Z

java-单例Bean如何处理并发请求?

我有一个关于单例bean如何详细处理并发请求的问题。

我已经在StackOverflow上搜索了有关此问题的信息。 这是来自stackoverflow的示例链接,但是我只找到了高级细节。 我想要有关单例bean如何处理并发请求以及系统处理器如何看到这些请求的完整详细信息。

我已经研究了有关在线处理系统处理器中并发请求的问题。 他们说处理器本身有一个调度程序,调度程序将决定处理哪个请求。

好的。 如果假设我有一个以上的核心处理器,那么调度程序如何处理并发请求?

谁能向我解释有关单例bean如何为JVM和系统中的并发请求提供服务的分步过程?

让我用一个具体的例子来解释。 我有一个像playFootball这样的课程:

class Sports {
    public void playFootball() {
    }

    public void playVolleyBall() {
    }
}

有两个请求。第一个请求正在对创建的类Sports的单例实例执行playFootball方法。同时,另一个请求正在对同一创建的类Sports的相同单例实例执行playVolleyBall方法。

单例实例怎么可能?

trans by 2020-01-11T10:07:27Z

CodeGo.net>如何使BackgroundWorker返回一个obj

我需要让RunWorkerAsync()返回List<FileInfo>。如何从后台工作人员返回对象?

trans by 2020-01-10T10:40:49Z

java-使用volatile long有什么意义吗?

在我有两个线程对其进行读写的情况下,并且不希望取出锁的开销(或潜在的死锁风险)的情况下,有时会使用volatile592实例变量。 例如计时器线程定期更新一个int ID,该int ID在某些类中作为getter公开:

public class MyClass {
  private volatile int id;

  public MyClass() {
    ScheduledExecutorService execService = Executors.newScheduledThreadPool(1);
    execService.scheduleAtFixedRate(new Runnable() {
      public void run() {
        ++id;
      }
    }, 0L, 30L, TimeUnit.SECONDS);
  }

  public int getId() {
    return id;
  }
}

我的问题:鉴于JLS仅保证32位读取是原子性的,是否有任何使用可变长整型的意义? (即64位)。

警告:请不要回答说在synchronized上使用volatile是预优化的情况; 我很清楚如何/何时使用synchronized,但在某些情况下最好使用volatile。 例如,在定义用于单线程应用程序中的Spring bean时,我倾向于使用volatile实例变量,因为不能保证Spring上下文将在主线程中初始化每个bean的属性。

trans by 2020-01-09T04:38:10Z

并发性-什么时候在Java中使用volatile布尔而不是AtomicBoolean更可取?

这个问题已经在这里有了答案:

  • 挥发性布尔值与AtomicBoolean                                     10个答案

我已经看过SO中的其他volatile与Atomicxxxx问题(包括此问题),并阅读了java.util.current.atomic的描述,我对这些细微差别并不满意。

如果我试图在使用volatile booleanAtomicBoolean之间做出选择,那么除了AtomicBoolean提供的原子读取-修改-写入操作之外,还有其他实际区别吗? (例如compareAndSet()getAndSet()

假设我有

volatile boolean flag;

然后,一个或多个线程设置该标志(但不清除它)。 如果我有一个线程读取该标志,并且设置了该标志,则执行一个操作,然后清除该标志,是否为volatile boolean

就以下方面而言,AtomicBoolean是否比可变布尔值的成本更高?

  • 记忆空间
  • 性能下降(根据java.util.current.atomic描述,volatile boolean似乎需要内存隔离,AtomicBoolean似乎需要内存隔离+ CAS操作上的一些次要锁定)

我的直觉是只使用AtomicBoolean并保持安全,但是我想了解是否存在使用volatile boolean的情况(例如,如果我有成千上万的实例,而性能是一个问题)。

trans by 2020-01-07T15:46:34Z

c ++-无栈协程与有栈协程有何不同?

背景:

我之所以这么问,是因为我目前有一个具有许多(数百至数千)线程的应用程序。 这些线程中的大多数在大部分时间都处于空闲状态,等待将工作项放入队列中。 当工作项可用时,然后通过调用一些任意复杂的现有代码对其进行处理。 在某些操作系统配置上,应用程序会遇到控制最大用户进程数的内核参数,因此我想尝试减少工作线程数的方法。

我建议的解决方案:

似乎是基于协程的方法,用协程替换每个工作程序线程将有助于实现此目的。 然后,我可以有一个由实际(内核)工作线程池支持的工作队列。 将项目放置在特定协程的队列中进行处理时,会将条目放置在线程池的队列中。 然后它将恢复相应的协程,处理其排队的数据,然后再次将其暂停,以释放工作线程来执行其他工作。

实施细节:

在考虑如何执行此操作时,我很难理解无栈协程和有栈协程之间的功能差异。 我有一些使用Boost.Coroutine库使用堆栈协程的经验。 我发现从概念上理解相对容易:对于每个协程,它维护CPU上下文和堆栈的副本,并且当您切换到协程时,它将切换到该保存的上下文(就像内核模式调度程序那样 )。

我不太清楚的是无栈协程与此有何不同。 在我的应用程序中,与上述工作项排队相关的开销非常重要。 我见过的大多数实现(例如新的CO2库)都建议无堆栈协程提供开销更低的上下文切换。

因此,我想更清楚地了解无栈协程和有栈协程之间的功能差异。 具体来说,我想到了以下问题:

  • 像这样的引用表明,区别在于您可以在有堆栈的协程与无堆栈的协程中屈服/恢复。 是这样吗 是否有一个简单的示例,说明我可以在堆栈式协程中执行某些操作,但不能在无堆栈的协程中执行某些操作?

  • 使用自动存储变量(即“在堆栈上”的变量)是否有任何限制?

  • 我可以从无堆栈协程调用哪些函数有任何限制?

  • 如果没有为无堆栈协程保存堆栈上下文,那么当协程运行时,自动存储变量会移到哪里?

trans by 2020-01-07T02:55:45Z

java-CopyOnWriteArrayList如何是线程安全的?

我看了CopyOnWriteArrayList的OpenJDK源代码,似乎所有写操作都受同一锁保护,而读操作则根本不受保护。 据我了解,在JMM下,对变量的所有访问(读和写)都应受锁保护,否则可能会发生重新排序的效果。

例如,CopyOnWriteArrayList方法包含以下几行(处于锁定状态):

/* 1 */ int len = elements.length;
/* 2 */ Object[] newElements = Arrays.copyOf(elements, len);
/* 3 */ newElements[index] = element;
/* 4 */ setArray(newElements);

另一方面,CopyOnWriteArrayList方法仅适用return get(getArray(), index);

以我对JMM的理解,这意味着,如果将语句1-4重新排序为1-2(new)-4-2(copyOf)-3,则CopyOnWriteArrayList可能会以不一致的状态观察到该数组。

我是否对JMM理解不正确,还是对CopyOnWriteArrayList为什么是线程安全的有其他解释?

trans by 2020-01-05T20:14:45Z

并发模型:Erlang vs Cloju

我们将使用Clojure编写并发程序,该程序将从大量传入的邮件中提取关键字,这些邮件将与数据库进行交叉检查。

我的一个队友建议使用Erlang编写此程序。

在这里,我想指出一些函数编程新手,因此我有点怀疑clojure是编写此程序的不错选择,还是Erlang更合适。

trans by 2020-01-04T08:37:51Z

并发-Scala Futures-内置超时?

我从官方教程参考中不完全了解期货的一个方面。 [http://docs.scala-lang.org/overviews/core/futures.html]

Scala中的期货是否具有某种内置的超时机制? 假设下面的示例是一个5 GB的文本文件...“ Implicits.global”的隐式范围是否最终导致onFailure以非阻塞方式触发或可以定义? 而且,如果没有某种默认的超时时间,这是否意味着不可能成功也不会失败?

import scala.concurrent._
import ExecutionContext.Implicits.global

val firstOccurence: Future[Int] = future {
  val source = scala.io.Source.fromFile("myText.txt")
  source.toSeq.indexOfSlice("myKeyword")
}
firstOccurence onSuccess {
  case idx => println("The keyword first appears at position: " + idx)
}
firstOccurence onFailure {
  case t => println("Could not process file: " + t.getMessage)
}
trans by 2020-01-03T08:11:30Z

java-分布式并发Con

我已经为此工作了几天,已经找到了几种解决方案,但是都没有一个非常简单或轻巧的解决方案。 问题基本上是这样的:我们有一个由10台计算机组成的群集,每台计算机都在多线程ESB平台上运行相同的软件。 我可以相当轻松地处理同一台计算机上线程之间的并发问题,但是不同机器上同一数据上的并发又如何呢?

本质上,该软件接收请求,以通过Web服务将客户数据从一家公司传送到另一家公司。 但是,客户可能存在或可能不存在于另一个系统上。 如果没有,我们将通过Web服务方法创建它。 因此,它需要某种测试和设置,但是我需要某种信号量,以防止其他计算机出现竞争状况。 我曾经遇到过这样的情况,即为单个本地客户创建了两次远程客户,这并不是很理想。

从概念上讲,我喜欢的解决方案是:

  1. 使用我们的容错共享文件系统创建“锁定”文件,每台机器将根据客户检查这些文件

  2. 在我们的数据库中使用一个特殊的表,并锁定整个表,以便对锁定记录进行“测试并设置”。

  3. 使用Terracotta,这是一种开放源代码服务器软件,可帮助扩展规模,但使用中心辐射型模型。

  4. 使用EHCache同步复制内存中的“锁”。

我无法想象我是唯一遇到过此类问题的人。 您是如何解决的? 您是在内部做饭还是有喜欢的第三方产品?

trans by 2020-01-03T05:30:35Z

并发性:C ++ 11内存模块中的原子和易失性

全局变量在2个不同内核上的2个同时运行的线程之间共享。 线程写入和读取变量。 对于一个原子变量,一个线程可以读取一个过时的值吗? 每个内核可能在其缓存中具有共享变量的值,并且当一个线程将其副本写入缓存中时,另一个内核上的另一个线程可能会从其自己的缓存中读取陈旧的值。 还是编译器执行强大的内存排序以从其他缓存中读取最新值? c ++ 11标准库具有std :: atomic支持。 这与volatile关键字有何不同? 在上述情况下,挥发性和原子类型的行为将如何不同?

trans by 2020-01-02T17:49:47Z

java-Future超时会终止线程执行吗

当使用ExecutorService和2684138682243875875对象(提交Runnable任务)时,如果我为Future的get函数指定了超时值,则抛出2684138682243875875842时基础线程会被杀死吗?

trans by 2020-01-02T00:27:18Z

语言不可知论-互斥体如何实现?

对于特定的应用程序,某些实现是否比其他实现更好? 推出自己的东西有什么可赚的?

trans by 2020-01-01T09:56:51Z

多线程-j中的程序化死锁检测

如何以编程方式检测到Java程序中已发生死锁?

trans by 2019-12-26T01:53:47Z

并发-goroutines如何工作? (或:goroutines与操作系统线程的关系)

其他goroutine在调用syscall时如何继续执行? (使用GOMAXPROCS = 1时)
据我所知,调用syscall时,线程放弃控制,直到syscall返回。Go如何在不按每个系统调用阻塞程序创建系统线程的情况下实现这种并发性?

从文档中:

Goroutines

之所以称为goroutine,是因为现有的术语(线程,   协程,流程等-传达了不准确的含义。 一种   goroutine有一个简单的模型:它是一个并发执行的函数   与其他goroutines在相同的地址空间中。 它很轻巧   仅花费分配堆栈空间的费用。 和堆栈   从小开始,所以它们很便宜,并且通过分配(和释放)来增长   根据需要堆存储。

Goroutines被多路复用到多个OS线程上,因此如果一个   阻塞,例如在等待I / O时,其他继续运行。 其   设计隐藏了线程创建的许多复杂性,并且   管理。

trans by 2019-12-26T01:50:33Z

java-等到Future <T>中的任何一个成为don

我运行的异步任务很少,我需要等到至少其中一个完成为止(将来可能需要等待N个任务中的util M完成)。目前,它们以“未来”的形式出现,所以我需要类似

/**
 * Blocks current thread until one of specified futures is done and returns it. 
 */
public static <T> Future<T> waitForAny(Collection<Future<T>> futures) 
        throws AllFuturesFailedException

有没有这样的东西? 或类似的东西,对于Future来说不是必需的。 目前,我循环浏览期货,检查一项是否完成,然后入睡一段时间,然后再次检查。 这似乎不是最佳解决方案,因为如果我长时间睡眠,则会增加不必要的延迟;如果我短期睡眠,则会影响性能。

我可以尝试使用

new CountDownLatch(1)

并在任务完成时减少倒计时

countdown.await()

,但我发现只有在我控制Future创建时才有可能。 这是可能的,但需要重新设计系统,因为当前任务创建的逻辑(将Callable发送给ExecutorService)与决定等待哪个Future分开。 我也可以覆盖

<T> RunnableFuture<T> AbstractExecutorService.newTaskFor(Callable<T> callable)

并创建RunnableFuture的自定义实现,并具有将任务完成时通知的附加侦听器,然后将此类侦听器附加到所需任务并使用CountDownLatch的功能,但这意味着我必须为我使用的每个ExecutorService覆盖newTaskFor-可能会有实现 不会扩展AbstractExecutorService。 我也可以尝试出于相同的目的包装给定的ExecutorService,但随后我必须装饰产生Futures的所有方法。

所有这些解决方案可能都有效,但看起来非常不自然。 似乎我缺少一些简单的东西,例如

WaitHandle.WaitAny(WaitHandle[] waitHandles)

在C#中。 是否有针对此类问题的知名解决方案?

更新:

最初,我根本无法使用Future创作,因此没有优雅的解决方案。 重新设计系统后,我可以访问Future创建并能够将countDownLatch.countdown()添加到执行过程中,然后我可以countDownLatch.await()正常运行。感谢您提供其他答案,我不知道ExecutorCompletionService,它确实对类似的任务有帮助,但是在这种特殊情况下,由于某些Futures没有任何执行程序就创建了,因此无法使用它-实际任务通过网络发送到另一台服务器, 远程完成并收到完成通知。

trans by 2019-11-18T16:32:25Z

1 2 3 4 5 6 下一页 共6页