synchronized是对象锁,也就是多线程操作某一个对象时对该对象的所有同步资源进行锁定。
// class MyObject
public class MyObject {
synchronized public void methodA() {
try{
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end methodA, endTime=" + System.currentTimeMillis());
} catch(InterruptedException e) {
e.printStackTrace();
}
}
public void methodB() {
try{
System.out.println("begin methodB threadName=" + Thread.currentThread().getName()
+ " begin time=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end methodB, endTime=" + System.currentTimeMillis());
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
// class ThreadA
public class ThreadA extends Thread {
private MyObject object;
public ThreadA(MyObject object) {
this.object = object;
}
@Override
public void run() {
super.run();
object.methodA();
}
}
// class ThreadB
public class ThreadB extends Thread {
private MyObject object;
public ThreadB(MyObject object) {
this.object = object;
}
@Override
public void run() {
super.run();
object.methodB();
}
}
// main class
public static void main(String[] args) {
myObject();
}
private static void myObject() {
MyObject object = new MyObject();
ThreadA threadA = new ThreadA(object);
threadA.setName("A");
ThreadB threadB = new ThreadB(object);
threadB.setName("B");
threadA.start();
threadB.start();
}
输出结果:
begin methodA threadName=A
begin methodB threadName=B begin time=1496543751228
end methodA, endTime=1496543756228
end methodB, endTime=1496543756228
从上面的结果可以看出,线程A和线程B在调用MyObject 类的同一个对象的不同方法是异步的,线程A调用methodA是所属临界资源,需要加同步锁,但是线程B调用的methodB并不属于临界资源,即使线程A获得了对象的锁也不影响线程B调用非临界资源methodB。
我们将MyObject的methodB也加上synchronized关键字,将该方法修改为临界资源。如下所示:
public class MyObject {
synchronized public void methodA() {
try{
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end methodA, endTime=" + System.currentTimeMillis());
} catch(InterruptedException e) {
e.printStackTrace();
}
}
synchronized public void methodB() {
try{
System.out.println("begin methodB threadName=" + Thread.currentThread().getName()
+ " begin time=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end methodB, endTime=" + System.currentTimeMillis());
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
其他代码不变,再运行一下结果如下:
begin methodA threadName=A
end methodA, endTime=1496543732497
begin methodB threadName=B begin time=1496543732497
end methodB, endTime=1496543737498
从以上输出结果可以看出,在线程A执行methodA时,线程B是在等待状态的,必须等线程A执行完methodA后释放了对象锁,然后线程B才可以执行methodB方法。
在线程A执行methodA时,线程A获得了MyObject类的对象object的锁,也就是object的所有被synchronized关键字修饰的变量和方法都只能被线程A所使用,其他线程必须等待线程A使用完成后释放对象锁后才能去获取object对象的锁,然后去执行object对象的方法。
结论:
1) A线程先持有object对象的lock锁,B线程可以以异步的方式调用object对象中的非synchronized类型的方法。
2) A线程先持有object对象的lock锁,B线程如果在这时调用object对象中的synchronized类型的方法则需要等待,也就是同步。