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

关于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

1 楼 jamesby 2006-12-30

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

2 楼 jamesby 2006-12-30

引用

public class ThreadTest implements Runnable {
    public void run() {
    }
    public static void main(String[] args) {
        ThreadTest threadTest= new ThreadTest();
        Thread threadA = new Thread(threadTest, "A");
        Thread threadB = new Thread(threadTest, "B");
        threadA.start();
        threadB.start();
    }
}

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

3 楼 Godlikeme 2006-12-30

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

4 楼 XMLDB 2006-12-30

Godlikeme 写道

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

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

5 楼 jamesby 2006-12-30

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

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

6 楼 Godlikeme 2006-12-30

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

7 楼 jamesby 2006-12-31

Godlikeme 写道

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

8 楼 jamesby 2006-12-31

5.0中锁的使用方式

Lock lock = new ReentrantLock();

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

9 楼 lzzzl 2007-01-12

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

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

10 楼 skydream 2007-01-17

这个东西一直感觉应该是挺简单的，怎么越说越糊涂了？我说几个我的理解吧，如果有误请大家指出：

1.synchronized是锁对象，根本不存在锁代码块的概念
2.synchronized锁定的对象
   (1)synchronized(obj){}-> 这个当然是锁obj
   (2)public void synchronized function(){} -> 这个锁的是function这个方法所在的对象，相当于
     public void function() {
        synchronized(this){}
     }
   (3)public static void synchronized function() ->对于静态方法，锁定的是当前类(假设是类TestClass)的Class对象,相当于
     public static void function() {
         synchronized(TestClass.class) {}
     }
3.jdk1.5中的concurrent包
    这个东西一直就存在的，没记错的话是一个大学的教授写的（名字忘了，挺佩服这人的），一直都是以一个工具包的形式存在，因为这个包写的太好，jdk1.5时被收录到jdk的标准包，以java.util.concurrent的形式出现。
    这个concurrent包实际也是对java的同步，锁这些操作的一个代码封装， java本身的机制并没有做任何修改。
    对于jdk1.5以前的jdk如jdk1.4，可以去找concurrent这个包的以前的版本,google一下应该就能出来的,不必拘泥于jdk1.5。

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

相关推荐