线程同步的实现方式有2种——方法同步和块同步,在java中会用到synchronized 这个关键字,它可以修饰:
- 非静态方法
- 静态方法
- 方法块
修饰方法时,注意不能是抽象类的抽象方法,也不能是接口中的方法。
如:
//do something
}
public void method2() {
synchronized (this) {
//do something
}
}
public static synchronized void method3(){
//do something
}
下面一段文字 引自http://blog.csdn.net/yakihappy/article/details/3979905
线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。
同步块是通过锁定一个指定的对象,来对同步块中包含的代码进行同步;而同步方法是对这个方法块里的代码进行同步,而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢?那么线程锁定的就不是这个类的对象了,也不是这个类自身,而是这个类对应的java.lang.Class类型的对象(如 XXX.class)。
同步方法和同步块之间的相互制约只限于同一个对象之间,所以静态同步方法只受它所属类的其它静态同步方法的制约,而跟这个类的实例(对象)没有关系。
如果一个对象既有同步方法,又有同步块,那么当其中任意一个同步方法或者同步块被某个线程执行时,这个对象就被锁定了,其他线程无法在此时访问这个对象的同步方法,也不能执行同步块。
上面的文字,前人总结得非常好也很精辟。在此主要是结合一些例子来理解上面的含义。
还是按照惯例,直接上代码:
public class ThreadSyncDemo {
/**
* Group 1
*/
public synchronized void sync1_0() {
System.out.println("sync1_0");
}
public synchronized void sync1_1() {
System.out.println("sync1_1");
}
public void sync1_2() {
synchronized (this) {
System.out.println("sync1_2");
}
}
public void sync1_3() {
System.out.println("before sync1_3");
synchronized (this) {
System.out.println("sync1_3");
}
System.out.println("after sync1_3");
}
/**
* Group 2
*/
public static synchronized void sync2_0(){
System.out.println("sync2_0");
}
public static synchronized void sync2_1(){
System.out.println("sync2_1");
}
public static void sync2_2() {
synchronized (ThreadSyncDemo.class) {
System.out.println("sync2_2");
}
}
public void sync2_3(){
synchronized (ThreadSyncDemo.class) {
System.out.println("sync2_3");
}
}
public void sync2_4(){
synchronized (this.getClass()) {
System.out.println("sync2_3");
}
}
/**
* Group 3
*/
private final Object lockObject = new Object();
public void sync3_0() {
synchronized (lockObject) {
System.out.println("sync3_0");
}
}
public void sync3_1() {
synchronized (lockObject) {
System.out.println("sync3_1");
}
}
/**
* Group 4
*/
private final static Object SLockObject = new Object();
public void sync4_0() {
synchronized (SLockObject) {
System.out.println("sync4_0");
}
}
public void sync4_1() {
synchronized (SLockObject) {
System.out.println("sync4_1");
}
}
public static void sync4_2() {
synchronized (SLockObject) {
System.out.println("sync4_2");
}
}
}
首先对上述示例来个总结:
- Group1中,共享数据为自身实例对象,对于同一个实例对象来说这组方法或块互斥。
- Group2中,共享数据为类对象,对于此类或此类的实例对象,这组方法或块互斥。
- Group3中,共享数据为自身实例对象的一个属性的值对象,对于同一个实例对象来说这组方法或块互斥。
- Group4中,共享数据为类对象的一个静态属性的值对象,对于此类或此类的实例对象,这组方法或块互斥。
- Group1/2/3/4之间无相关性。
简而言之,synchronized 关键字是用于保护共享数据,只有分清了共享数据,我们才知那些方法或块互为同步。
此外,上面的示例代码可以按下面的方法来测试:
public static void main(String[] args) {
final ThreadSyncDemo tsd = new ThreadSyncDemo();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
tsd.sync4_0(); //
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
ThreadSyncDemo.sync4_2(); //
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
}
}
}
}).start();
}
使用eclipse在代码8和21行处加入断点,在调试模式下观察2个线程访问同步资源时的运行状态。第8/21行处的代码可以换Group1/2/3/4中的方法进行配对测试。