Tag: 同步

java中的单例模式。 懒惰的初始化

public static MySingleton getInstance() { if (_instance==null) { synchronized (MySingleton.class) { _instance = new MySingleton(); } } return _instance; } 1.上面的getInstance方法实现有缺陷吗？ 2.这两种实现有什么区别。 public static synchronized MySingleton getInstance() { if (_instance==null) { _instance = new MySingleton(); } return _instance; } 我已经在stackoverflow中看到了很多关于单例模式的答案，但我发布的问题主要是知道在这种特殊情况下方法和块级别的’synchronize’的区别。

Java：ArrayBlockingQueue与LinkedBlockingQueue

我认为，在大多数情况下， ArrayBlockingQueue性能优于LinkedBlockingQueue 。 但是，当数组中总有足够的空间时就是这种情况……如果它变满，那么它是否会表现得如此之好并不是很可预测，因为它会阻塞试图将数据推入队列的线程。 。 所以，我的问题是：是否有BlockingQueue中间实现？ BucketListBlockingQueue说， ArrayListBlockingQueue或BucketListBlockingQueue ？ 类似于数组列表的东西，这样队列可以动态增加容量，同时仍然可以通过使用数组最终存储数据获得合理的好处？

请解释Java内存模型中详述的初始化安全性

有人可以解释Java内存模型所要求的初始化安全性吗？ 最终字段如何帮助实现初始化安全性 ？ 构造函数在确保初始化安全性方面起什么作用？

在notifyAll（）之前未被线程锁定的同步对象

我想要一个布尔值来通知系统某些特定服务启动的部分。 出于某些奇怪的原因，我收到错误java.lang.IllegalMonitorStateException: object not locked by thread before notifyAll() 。 奇怪的是，notifyAll（）位于一个synchronized块中，该块控制我调用notifyAll（）的对象。 我的class级开头是这样的： public class MyService { public static Boolean notifier = Boolean.valueOf(false); @Override public void start() { synchronized (MyService.notifier) { MyService.notifier = Boolean.valueOf(true); MyService.notifier.notifyAll(); } } @Override public void stop() { synchronized (MyService.notifier) { MyService.notifier = Boolean.valueOf(false); MyService.notifier.notifyAll(); } } … } 我正在开发一个Android应用程序。 我认为它不应该影响任何东西，但是如果影响java的工作方式，我会用该注释补充问题。 如果对象锁定在同步块中，为什么会出现exception？

Java的。 在multithreading环境中序列化对象

我有一个对象，其内部可变状态由一个或多个线程不断更新。 对象是同步的，目标是定期从另一个线程保存其状态（通过序列化）： public class Counter implements Serializable { private int dogCount; private int catCount; public synchronized void updateFromDogThread( int count ) { dogCount = count; } public synchronized void updateFromCatThread( int count ) { catCount = count; } } 问题： 在这种情况下序列化安全吗？ 它是如何在引擎盖下工作的？ 也就是说， ObjectOutputStream执行序列化块直到没有线程再次在Counter运行？ 如果Counter的同步不使用内部锁定，而是使用其他锁定怎么办？

不可变对象的同步（在java中）

代码段 – 1 class RequestObject implements Runnable { private static Integer nRequests = 0; @Override public void run() { synchronized (nRequests) { nRequests++; } } } 代码段 – 2 public class Racer implements Runnable { public static Boolean won = false; @Override public void run() { synchronized (won) { if (!won) won = true; } […]

死锁和同步方法

我在Stack Overflow上找到了一个代码，我认为它与我面临的非常相似，但我仍然不明白为什么会出现这种情况。 该示例取自Java中的死锁检测 ： Class A { synchronized void methodA(B b) { b.last(); } synchronized void last() { System.out.println(“ Inside A.last()”); } } Class B { synchronized void methodB(A a) { a.last(); } synchronized void last() { System.out.println(“ Inside B.last()”); } } Class Deadlock implements Runnable { A a = new A(); B b = […]

Java线程同步 – Thread.sleep（）方法不按预期工作

我听说，sleep（）将锁定当前的sync方法/块但是在这里，当我在线程1上调用sleep（）时，线程2能够访问同一个块吗？ 谁能解释一下吗？ Main.java public class Main { public static void main(String args[]) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); System.out.println(“going to start t1”); t1.start(); System.out.println(“going to start t2”); t2.start(); } } ================================================== =================== Thread1.java public class Thread1 extends Thread{ public void run() { Syncc s1 = new Syncc(); s1.me(“T1:”); } } […]

锁定可变对象 – 为什么它被认为是一种不好的做法？

看到这个答案 。 它说： 六个非常糟糕的例子; … 锁定可变字段。 例如synchronized（object）{object = …; } 锁定可变字段有什么问题？ 如果object被声明为final但不是不可变类，该怎么办？

Java – 同步静态方法

这是我在此链接中找到的一段文字。 “避免锁定静态方法 最糟糕的解决方案是将“synchronized”关键字放在静态方法上，这意味着它将锁定此类的所有实例。“ 为什么同步静态方法会锁定类的所有实例？ 它不应该只是锁定类吗？