Java多线程——synchronized的问题

一直以来都存在这样的问题：

多线程操作同一对象。该对象有一个方法为m1，另一个方法为m2，那么当有一条线程执行m1时，同时该线程获得该对象的锁。那么另一个线程能否调用m2呢？

 

试验代码1：

public class ThreadSafeObject {
	public int i=0;
	public synchronized void add(){
		System.out.println(Thread.currentThread().getName()+"；开始调用safeObject的add()方法，调用之前的值为："+i);
		System.out.println("add方法执行5s");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		i++;
		System.out.println(Thread.currentThread().getName()+"；开始调用safeObject的sub()方法，调用之后的值为："+i);
	}
	
	public synchronized void sub(){
		System.out.println(Thread.currentThread().getName()+"；开始调用safeObject的sub()方法，调用之前的值为："+i);
		System.out.println("sub方法执行1s");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		i--;
		System.out.println(Thread.currentThread().getName()+"；开始调用safeObject的sub()方法，调用之后的值为："+i);
		
	}
	
}

 

public class TestThreadAdd  implements Runnable{
	ThreadSafeObject safeObject ;
	
	public TestThreadAdd(ThreadSafeObject safeObject){
		 this.safeObject = safeObject;
	}
	
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"，开始执行。");
		safeObject.add();
		System.out.println(Thread.currentThread().getName()+"，结束执行。");
		
	}
	
}

 

public class TestThreadSub  implements Runnable{
	ThreadSafeObject safeObject ;
	
	public TestThreadSub(ThreadSafeObject safeObject){
		 this.safeObject = safeObject;
	}
	
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"，开始执行。");
		safeObject.sub();
		System.out.println(Thread.currentThread().getName()+"，结束执行。");
	}
	
}

 

public class Main {
	public static void main(String[] args) throws InterruptedException {
		ThreadSafeObject threadSafeObject = new ThreadSafeObject();
		
		new Thread(new TestThreadAdd(threadSafeObject)).start();
		Thread.sleep(200);
		new Thread(new TestThreadSub(threadSafeObject)).start();
		
	}
}

该代码段的执行结果如下：

Thread-0，开始执行。
Thread-0；开始调用safeObject的add()方法，调用之前的值为：0
add方法执行5s
Thread-1，开始执行。
Thread-0；开始调用safeObject的sub()方法，调用之后的值为：1
Thread-1；开始调用safeObject的sub()方法，调用之前的值为：1
sub方法执行1s
Thread-0，结束执行。
Thread-1；开始调用safeObject的sub()方法，调用之后的值为：0
Thread-1，结束执行。

 

可以看到当Thread-0执行了5s的add()方法后，Thread-1才能执行sub()方法。

可见，当Thread-0没有执行完add()方法之前，Thread-1是被阻塞的，且是没有获取线程锁的方式阻塞。

 

 

 

试验代码2：

把ThreadSafeObject的sub()方法的synchronized去掉。

public class ThreadSafeObject {
	......
	
	public /*synchronized*/ void sub(){
                ......
		
	}
	
}

 执行结果如下：

Thread-0，开始执行。
Thread-0；开始调用safeObject的add()方法，调用之前的值为：0
add方法执行5s
Thread-1，开始执行。
Thread-1；开始调用safeObject的sub()方法，调用之前的值为：0
sub方法执行1s
Thread-1；开始调用safeObject的sub()方法，调用之后的值为：-1
Thread-1，结束执行。
Thread-0；开始调用safeObject的sub()方法，调用之后的值为：0
Thread-0，结束执行。

 

可以看到：Thread-1没有等Thread-0的执行结束。即Thread-1不需要去获取共有对象的锁。

 

 

试验结论

synchronized关键字是强制线程获取对象的锁标志。如果没有该关键字，则线程不去等待锁的获取，而直接操作对象。