Tag: 并发

AtomicInteger何时优先于同步？

由于AtomicInteger至少比synchronized保护的int慢一个数量级，为什么我要使用AtomicInteger？ 例如，如果我想要的是以线程安全的方式增加int值，为什么不总是使用： synchronized(threadsafeint) { threadsafeint++; } 而不是使用慢得多的AtomicInteger.incrementAndGet（） ？

生产者/消费者 – 生产者将数据添加到集合中而不会阻塞，消费者会批量使用集合中的数据

我有一个生产者/消费者用例，这有点不寻常。 我有一些真实世界的用例，我希望他们能够在没有阻塞的情况下将对象添加到集合中。 消费者（只有一个）应该阻止，直到集合中有一定数量的对象可用（例如500），然后批量消费它们。 虽然少于500，但它应该阻止并等待集合填充。 我不介意队列是否超过这个值（700,1000等）很短的时间。 我目前似乎没有找到解决这个确切问题的解决方案。 我正在考虑使用ConcurrentLinkedQueue并让消费者定期检查队列是否有足够的数据，但这似乎适得其反。 另一个想法是使用LinkedBlockingQueue。 生产者不会阻止（除非队列已满，这意味着它有Integer.MAX_VALUE值 – 这不是我的情况，所以这一切都很好）。 使用者将执行queue.take（）并将元素添加到内部集合中。 当内部集合达到500个元素时，它将批量使用它们。 你有什么建议吗？ 谢谢！

使用primefaces变量在Java中实现互斥锁

我想使用primefaces变量在Java中实现一个互斥锁。 我尝试使用lamport烘焙算法实现它，它的工作原理。 但是我不知道如何实现它，如果我之前不知道线程的数量。 此外，lamport算法不断增加标签，并且会出现溢出，如何避免这种情况？

multithreadingJava，但只有一个线程工作

我的Java线程无法独立工作，如何解决？ 这是最初的主要内容： Mechanics mechanics = new Mechanics(busShop, “Mechanic 1”); Mechanics mechanics2 = new Mechanics(busShop, “Mechanic 2”); Thread thMechanic = new Thread(mechanics); Thread thMehanic2 = new Thread(mechanics2); thMechanic.start(); thMehanic2.start(); 到目前为止没问题，按预期工作，所以机械师这样做： public void run() { fixEngine(); } private void fixEngine() { while (true) { busShop.FixEngine(MechanicsName); } } 正如此处所见，它可以永久修复引擎，在修复引擎function中： public static List ListBusEngineFix = new LinkedList(); public void […]

键盘Actionlistener

我试图让我的游戏中的太空飞船（PlayerShip.gif）在按下相应的键时向左，向右，向上和向下移动。 我知道我需要一个keyboardListener，但我有问题弄清楚它到底去了什么以及它实际上是如何实现的。 我的代码如下。 public class GamePanel extends JPanel implements KeyListener { Timer timer1; Timer timer2; ArrayList ship; int x; int y; double speed; int size; int shipxCoord; int shipyCoord; int shipHeight; int shipWidth; int shipRise; int shipRun; boolean left = false; boolean right = false; boolean up = false; boolean down = false; Image enemyShip1; […]

什么是Java的java.util.concurrent包的.NET等价物？

我来自Java背景。 我想在.Net和C＃中更多地了解并发性。 是否有类似Java的并发工具包？

在Java中对volatile对象进行非易失性引用的行为

来自C / C ++，我对Java中的volatile对象行为有点困惑。 我知道Java中的volatile有两个属性： 不会将对象带入缓存，始终将其保存在主内存中。 保证“发生在之前” 但是我不确定如果我对对象进行新的非易失性引用会发生什么。 例如， class Example { private volatile Book b = null; public init() { b = new Book(…); } public use() { Book local = b; local.read(); } } AFAIK，volatile表示b引用的“book对象”应该在主内存中。 编译器可能在内部实现引用作为指针，因此b指针可能位于缓存中。 根据我的理解，volatile是对象的限定符，而不是引用/指针。 问题是：在use方法中，本地引用不是volatile。 这个“本地”引用是否会将基础Book对象从主内存带入缓存，从根本上使对象不“易变”？

如何避免嵌套同步和导致的死锁

我需要在一个function中锁定两个对象，并且当前代码如下所示; Object obj1 = …//get from somewhere Object obj2 = …//get from somewhere synchronized(obj1){ …//blah synchronized(obj2){ …//blah } } 正如你所看到的，如果另一个线程使用obj1运行这段代码并且两个反转，这是一个简单而直接的死锁配方。 有没有办法使用concurrency-utils锁来避免这种情况？ 我正在考虑维护一个物体及其锁定的地图并validation它们是否可以使用，但似乎无法想出一种可以预测锁定顺序的干净方式。

Spring @Transactional并发

class MyService { public void a() { synchronized(somekey) { b(); } } @Transactional(propagation = Propagation.REQUIRES_NEW) public void b() { …do DB works… } } class MyService { public void a() { synchronized(somekey) { b(); } } @Transactional(propagation = Propagation.REQUIRES_NEW) public void b() { …do DB works… } } class MyService { public void a() { […]

java 8：LongAdder和LongAccumulator是AtomicLong的首选吗？

LongAdder作为AtomicLong的替代品 ExecutorService executor = Executors.newFixedThreadPool(2); IntStream.range(0, 1000) .forEach(i -> executor.submit(adder::increment)); stop(executor); System.out.println(adder.sumThenReset()); // => 1000 LongAccumulator是LongAccumulator的更通用版本 LongBinaryOperator op = (x, y) -> 2 * x + y; LongAccumulator accumulator = new LongAccumulator(op, 1L); ExecutorService executor = Executors.newFixedThreadPool(2); IntStream.range(0, 10) .forEach(i -> executor.submit(() -> accumulator.accumulate(i))); stop(executor); System.out.println(accumulator.getThenReset()); // => 2539 我有一些疑问。 LongAdder总是优先于AtomicLong吗？ LongAccumulator是LongAdder和AtomicLong的首选吗？