关于Java的线程同步问题的总结

第一种情况，synchronized无效

package com.test;
public class ThreadTest extends Thread {
	private int threadNo;
	public ThreadTest(int threadNo) {
		this.threadNo = threadNo;
	}
	public static void main(String[] args) throws Exception {
		for (int i = 1; i < 10; i++) {
			new ThreadTest(i).start();
			Thread.sleep(1);
		}
	}
	public synchronized void run() {
		for (int i = 1; i < 10000; i++) {
			System.out.println("No." + threadNo + ":" + i);
		}
	}
}

第二种情况，synchronized有效

package com.test;
public class ThreadTest2 extends Thread {
	private int threadNo;
	private String lock;
	public ThreadTest2(int threadNo, String lock) {
		this.threadNo = threadNo;
		this.lock = lock;
	}
	public static void main(String[] args) throws Exception {
		String lock = new String("lock");
		for (int i = 1; i < 10; i++) {
			new ThreadTest2(i, lock).start();
			Thread.sleep(1);
		}
	}
	public void run() {
		synchronized (lock) {
			for (int i = 1; i < 10000; i++) {
				System.out.println("No." + threadNo + ":" + i);
			}
		}
	}
}

第三种情况，synchronized有效

package com.test;
public class ThreadTest3 extends Thread {
	private int threadNo;
	private String lock;
	public ThreadTest3(int threadNo, String lock) {
		this.threadNo = threadNo;
		this.lock = lock;
	}
	public static void main(String[] args) throws Exception {
		String lock = new String("lock");
		for (int i = 1; i < 20; i++) {
			new ThreadTest3(i, lock).start();
			Thread.sleep(1);
		}
	}
	public static synchronized void abc(int threadNo) {
		for (int i = 1; i < 10000; i++) {
			System.out.println("No." + threadNo + ":" + i);
		}
	}
	public void run() {
		abc(threadNo);
	}
}

总结：
1、对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；
2、如果采用method级别的同步，则对象锁即为method所在的对象（怎么这么别扭），如果是静态方法，对象锁即指method所在的Class对象(唯一)；
3、对于代码块则，对象锁即指synchronized(abc)中的abc；
4、因为第一种情况，对象锁即为每一个线程对象，因此有多个，所以同步失效，第二种共用同一个对象锁lock，因此同步生效，第三个因为是static因此对象锁为ThreadTest3的class 对象，因此同步生效。

如上述正确，则同步有两种方式，代码块和方法
如果是代码块，则对象锁自己指定，一般有些代码为synchronized(this)只有在单态模式才生效；
如果是方法，则分静态和非静态两种。
静态方法则一定会同步，非静态方法需在单例模式才生效，推荐用静态方法(不用担心是否单例)。
不知道以上说的对否，如不对请指点。

http://www.iteye.com/topic/48750

当然，如果有多个synchronized块，只要对象锁相同，如果有线程访问其中一个synchronized块，其它只能阻塞。

对于这种形式的多线程，ThreadTest实际也为单例模式，即对象只被创建一次，因此可以放心使用method级别的synchronized.

本来简单的东西这么一说到复杂了，
java本身的这个锁机制还是有一些问题，还是建议多研究下，jdk5concurrent包吧。

jdk5concurrent也是建立在java的锁机制上的.

to Godlikeme:
复杂的是锁的机制吧，那是JDK的事情，我们写程序不复杂吧！

jdk5concurrent什么东西？现在还在用1.4，有时间再看。

对java锁机制研究不深，转贴两片文章，觉得还不错，作为参考。
http://www.ibm.com/developerworks/cn/java/j-jtp11234/index.html
http://www.ibm.com/developerworks/cn/java/j-jtp10264/index.html

5.0 中好像对锁的机制改善很多,sychronized的锁应该是只实现一个等待锁,而5.0中又多了比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票等很多种,最大区别是5.0自定义锁,自己负责锁的释放.其它优势还不清楚.

5.0中锁的使用方式

Lock lock = new ReentrantLock();

lock.lock();
try { 
  // update object state
}
finally {
  lock.unlock(); 
}

没抓住要点！另外后2个示例的synchronized关键字在哪啊？

我这几天遇到同步问题，看了一篇文章，里面有一个关键的说法：“锁定的是对象而不是代码”，所以问题也就迎刃而解了。