关于单例模式和多线程之间无法实现的问题

单例模式：保证一个类仅有一个势力，并提供一个访问它的全局访问点，在编程实现的时候，我想让两个线程t1,、t2分别访问该实例，而且是互斥的访问，虽然Instance的互斥实现了，但是关于createSingletonInstance（）的互斥访问却没有实现，请问这是问什么，希望各位大虾给予解答，thx。

首先是Singleton类：

/**

*Singleton.java

*/

package shejimoshi.singleton;

/**

* @author xuhongbin

* @data2014年9月21日上午10:37:55

*/

public class Singleton {

private static Singleton instance;

private Singleton(){//构造方法让其private， 这就毒死了外界利用new 创建此类实例的可能

}

public static synchronized Singleton GetInstance(){

if(instance == null){

instance = new Singleton();

System.out.println(Thread.currentThread().getName()+"创建了instance实例");

}

return instance;

}

}

其次是线程及主函数：

/**

*TestSingleton.java

*/

package shejimoshi.singleton;

/**

* @author xuhongbin

* @data2014年9月21日下午2:30:37

*/

public class TestSingleton implements Runnable{

public static int i;

Singleton s;

/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

@Override

public void run() {

createSingletonInstance();

}

public synchronized void createSingletonInstance(){

s = Singleton.GetInstance();

i++;

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"线程调用了一个Singleton对象");

System.out.println("第"+i+"次调用Singleton对象。。。。。");

}

/**

* @param args

*/

public static void main(String[] args) {

Thread t1 = new Thread(new TestSingleton(), "ss1");

Thread t2 = new Thread(new TestSingleton(), "ss2");

t1.start();

t2.start();

}

}

一直出现这样的结果：

ss2创建了instance实例

ss2线程调用了一个Singleton对象

ss1线程调用了一个Singleton对象

第2次调用Singleton对象。。。。。

第2次调用Singleton对象。。。。。

而我想要线程互斥的访问，也就是后两句应该一个是“第1次调用......”, “第2次调用......”

希望尽快得到大家的解答，谢谢。。。

问题在这里http://bbs.csdn.net/topics/390890982?page=1#post-398229236

首先非常感谢：software_gemeng；javaliuliu；liudehuas5的解答

更改后代码如下:main函数做出了以下修改：

public static void main(String[] args) {
TestSingleton s = new TestSingleton();

Thread t1 = new Thread(s, "ss1");
Thread t2 = new Thread(s, "ss2");
t1.start();
t2.start();
}

然后运行成功，

结果为：

ss1创建了instance实例

ss1线程调用了一个Singleton对象

第1次调用Singleton对象。。。。。

ss2线程调用了一个Singleton对象

第2次调用Singleton对象。。。。。

问题的本质在于对synchronized，线程理解的不到位。

createSingletonInstance方法前加synchronized关键字是加对象锁，对象锁是对特定实例加锁(同一TestSingleton对象)，而非对TestSingleton类进行加锁。

在原始编码中，new了两个TestSingleton对象，他们是属于同一类的不同对象。所以即使有synchronized加锁，也不会有不同对象对i互斥访问。

而singleton的实例instance 为何可以实现互斥访问，原因是只有一个Singleton的实例instance，所以会互斥访问，那么接下来我们继续做实验：

将TestSingleton的i的static关键字去掉。

main函数中new出两个TestSingleton对象

(与原始代码相比只是将 TestSingleton中的static去掉，我想自己出现该错误的思维盲点就在这里,

Thread t1 = new Thread(new TestSingleton(), "s1");

Thread t2 = new Thread(new TestSingleton(), "s2");)

完全没有意识到是new出两个TestSingleton对象儿出现的问题）

那么更改后的代码为：

/**

*TestSingleton.java

*/

package shejimoshi.singleton;

/**

* @author xuhongbin

* @data2014年9月21日下午2:30:37

*/

public class TestSingleton implements Runnable{

public int i;

Singleton s;

/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

@Override

public void run() {

createSingletonInstance();

}

public synchronized void createSingletonInstance(){

s = Singleton.GetInstance();

i++;

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"线程调用了一个Singleton对象");

System.out.println("第"+i+"次调用Singleton对象。。。。。");

}

/**

* @param args

*/

public static void main(String[] args) {

TestSingleton s1 = new TestSingleton();

TestSingleton s2 = new TestSingleton();

Thread t1 = new Thread(s1, "s1");

Thread t2 = new Thread(s2, "s2");

t1.start();

t2.start();

}

}

运行结果为：

s1创建了instance实例

s2线程调用了一个Singleton对象

s1线程调用了一个Singleton对象

第1次调用Singleton对象。。。。。

第1次调用Singleton对象。。。。。

这下对于概念的理解就更加明了，由于是不同的Singleton对象，所以即使在createSingletonInstance()前加synchronized，也只能保证 特定TestSingleton实例(new出的TestSingleton对象，如s1，或者是s2)之间对i访问的互斥，而无法保证对对不同TestSingleton对象（如s1和s2）对i的互斥访问。

主函数如下更改则脉络更加清晰：

public static void main(String[] args) {
TestSingleton s1 = new TestSingleton();
TestSingleton s2 = new TestSingleton();

Thread t10 = new Thread(s1, "s10");
Thread t11 = new Thread(s1, "s11");

Thread t20 = new Thread(s2, "s20");
Thread t21 = new Thread(s2, "s21");
t10.start();
t11.start();
t20.start();
t21.start();
}

结果为：

s20创建了instance实例

s20线程调用了一个Singleton对象

s10线程调用了一个Singleton对象

第1次调用Singleton对象。。。。。

第1次调用Singleton对象。。。。。

s11线程调用了一个Singleton对象

第2次调用Singleton对象。。。。。

s21线程调用了一个Singleton对象

第2次调用Singleton对象。。。。。

可以看出 对象s1与s2之间的变量i毫无关系，而线程对象t10和t11（或者是t20和t21）之间对i的访问是互斥的。而且由于Single的实例instance只有一个且对调用它的函数是互斥访问的，所以instance在全局是互斥的。

终于搞明白了。。。