62,615
社区成员
发帖
与我相关
我的任务
分享关于synchronized同步的使用
几乎各种牛人的文章都说到单例模式的双重检查有问题，类似下面的代码
并且说到有问题的原因是可能另外的线程检测到instance不为空，但是对象还没有初始化好。
但是我疑虑的是，如果这种写法有问题的话，那也就意味着在synchronized中只要new了对象都有可能有问题。
例如下面的写法
或者是这样的
那如果这些代码都有问题的话，那就无数的代码都有问题，只要是涉及到需要在多线程中创建对象的都可能有这种问题。
虽然各种大牛都说第一段代码里的这种问题，可以依靠volatile来解决。但是后面两种呢，这没法用volatile解决的啊。
感谢赐教
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
并且说到有问题的原因是可能另外的线程检测到instance不为空，但是对象还没有初始化好。
但是我疑虑的是，如果这种写法有问题的话，那也就意味着在synchronized中只要new了对象都有可能有问题。
例如下面的写法
public static synchronized Object newobj(){
return new Object();
}
或者是这样的
public static synchronized void addobj(ArrayList list){
list.add(new Object());
}
那如果这些代码都有问题的话，那就无数的代码都有问题，只要是涉及到需要在多线程中创建对象的都可能有这种问题。
虽然各种大牛都说第一段代码里的这种问题，可以依靠volatile来解决。但是后面两种呢，这没法用volatile解决的啊。
感谢赐教
...全文
请发表友善的回复…
发表回复
cattpon 2018-03-16
- 打赏
- 举报
http://www.importnew.com/24082.html
rumlee 2018-03-15
- 打赏
- 举报
从本质上讲
public static void func(){
synchronized (Singleton.class) {
}
}
和
public static synchronized void func(){
}
是一样的啊。
oO临时工Oo 2018-03-15
- 打赏
- 举报
并且说到有问题的原因是可能另外的线程检测到instance不为空，但是对象还没有初始化好。
这个说法本身就是错误的，所以你提出问题的前提是错误的，因此，你提出的问题不存在。
如果理清单例模式的发展，你就知道你真正想问的问题是啥
以下是最简单的单例模式
public static Singleton getInstance() {
if (instance == null){
instance = new Singleton();
}
return instance;
}public static Singleton instance;
private static Object instanceLock = new Object();
public static Singleton getInstance2() {
synchronized (instanceLock) {
if (instance == null)
instance = new Singleton();
}
return instance;
}
public static Singleton getInstance3() {
if (instance == null) {
synchronized (instanceLock) {
if (instance == null)
instance = new Singleton();
}
}
return instance;
}oO临时工Oo 2018-03-15
- 打赏
- 举报
在thread1重新run的之前，thread2开始执行，thread2运行好，一下就执行完了，那么thread2势必会执行“new Singleton()”
当年我还小丶 2018-03-15
- 打赏
- 举报
按照这种说法，java所有刚创建的对象都会有没准备好就被使用的情况 ...
oyljerry 2018-03-15
- 打赏
- 举报
你看到的单例的代码，其实是做了发展的，可以看到synchronized 并没有加在getInstance方法上，如果加载这个上面就不会存在问题，因为每个函数都是加锁了的，所以不会出现实例不完整的问题，也就是后面的newobj()， addobj等方法使用的。
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)
instance = new Singleton();
}
}rumlee 2018-03-15
- 打赏
- 举报
是的，我说的两个例子与是否单例没啥关系。但是原理一样啊。
我的意思是单例模式里面的双重检查的问题如果存在的话，那我这两个例子中没有道理不存在类似问题啊。
可以推出我的例子中，同样可能存在引用准备好了或者已经返回了，而对象没有准备好的情况。
Braska 2018-03-15
- 打赏
- 举报
你那两个例子，连单例都算不上吧。
都是新的实例。
rumlee 2018-03-15
- 打赏
- 举报
public synchronized String toString() {
int max = size() - 1;
if (max == -1)
return "{}";
StringBuilder sb = new StringBuilder();
Iterator<Map.Entry<K,V>> it = entrySet().iterator();
sb.append('{');
for (int i = 0; ; i++) {
Map.Entry<K,V> e = it.next();
K key = e.getKey();
V value = e.getValue();
sb.append(key == this ? "(this Map)" : key.toString());
sb.append('=');
sb.append(value == this ? "(this Map)" : value.toString());
if (i == max)
return sb.append('}').toString();
sb.append(", ");
}
}
rumlee 2018-03-15
- 打赏
- 举报
我后面举的例子当然也可以被别的线程访问到啊。
import java.util.ArrayList;
import java.util.List;
public class Test implements Runnable {
private List<Object> list;
public Test() {
this.list = new ArrayList<Object>();
}
public static synchronized void addobj(List<Object> list) {
list.add(new Object());
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(this.list.get(this.list.size() - 1));
Test.addobj(this.list);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test t = new Test();
new Thread(t).start();
new Thread(t).start();
}
}
maradona1984 2018-03-15
- 打赏
- 举报
我后面举的例子当然也可以被别的线程访问到啊。
import java.util.ArrayList;
import java.util.List;
public class Test implements Runnable {
private List<Object> list;
public Test() {
this.list = new ArrayList<Object>();
}
public static synchronized void addobj(List<Object> list) {
list.add(new Object());
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(this.list.get(this.list.size() - 1));
Test.addobj(this.list);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test t = new Test();
new Thread(t).start();
new Thread(t).start();
}
}
rumlee 2018-03-15
- 打赏
- 举报
我后面举的例子当然也可以被别的线程访问到啊。
import java.util.ArrayList;
import java.util.List;
public class Test implements Runnable {
private List<Object> list;
public Test() {
this.list = new ArrayList<Object>();
}
public static synchronized void addobj(List<Object> list) {
list.add(new Object());
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(this.list.get(this.list.size() - 1));
Test.addobj(this.list);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test t = new Test();
new Thread(t).start();
new Thread(t).start();
}
}
oyljerry 2018-03-15
- 打赏
- 举报
从本质上讲
public static void func(){
synchronized (Singleton.class) {
}
}
和
public static synchronized void func(){
}
是一样的啊。[/quote]
不一样，主要是调用。虽然都是调用func，但是第一种，任何线程都能进入，而第二种，只有一个能进入[/quote]
第一种方法中，主要是为了进入func以后，可以不加锁的判断是否为空，来提高并发访问的速度。但是就会带来副作用。
oO临时工Oo 2018-03-15
- 打赏
- 举报
public static void func(){
synchronized (Singleton.class) {
}
}
和
public static synchronized void func(){
}
假如存在资源竞争，导致线程等待，第一个方法或比第二个方法多一个栈帧，多消耗微量的存储。
maradona1984 2018-03-15
- 打赏
- 举报
单例的instance变量可能被多个线程访问到
你后面举的例子,变量都在线程的工作内存中,在创建过程中不管CPU如何重排指令,其他线程也访问不到这个变量,自然不存在线程安全问题
pilnyun335857183 2018-03-15
- 打赏
- 举报
对象实例化过程的乱序写入问题？我的印象中现在的jmm应该不存在这个问题了，不记得是那个版本修复过；好像是将对象实例化过程中从内存分配、属性的初始化等都放在工作内存中进行最后同步主内存 其他线程不可能探知到变化的。先占个坑 找到详情再回复
oyljerry 2018-03-15
- 打赏
- 举报
从本质上讲
public static void func(){
synchronized (Singleton.class) {
}
}
和
public static synchronized void func(){
}
是一样的啊。[/quote]
不一样，主要是调用。虽然都是调用func，但是第一种，任何线程都能进入，而第二种，只有一个能进入
