在多线程访问同一个对象中的不同的synchronized方法或synchronized代码块的前提下，也就是“对象监控器”为同一个对象的时候，也就是synchronized的锁为同一把锁的时候，调用的效果就是：当前正在执行的synchronized方法或synchronized代码块的运行结果是同步的，但是对其synchronized方法或synchronized代码块来说是阻塞的。同步是因为当一个线程执行synchronized方法或代码块的时候，正常情况下，别的线程永远得不到CPU的执行机会。也就是因为别的线程永远得不到执行机会，所以其他synchronized方法和synchronized代码块没有机会被执行，造成阻塞。
其实Java还支持“任意对象”作为“对象监视器”，来实现同步的功能，这个“任意对象”大多数为实例变量或者方法形参，使用的格式为synchronized(非this对象)同步代码块。那么她的特点和synchronized(this)代码块是一样的，特点如下：在多个线程持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象)代码块里的代码。我写了一个小例子来证明，代码如下：
public static void main(String[] args) {
MyService1 service = new MyService1();
ThreadA a = new ThreadA(service);
a.setName("A");
ThreadB b = new ThreadB(service);
b.setName("B");
a.start();
b.start();
}
public static class ThreadA extends Thread {
private MyService1 service;
public ThreadA(MyService1 service) {
super();
this.service = service;
}
@Override
public void run() {
super.run();
service.serviceMethodA("a", "A");
}
}
public static class ThreadB extends Thread {
private MyService1 service;
public ThreadB(MyService1 service) {
super();
this.service = service;
}
@Override
public void run() {
super.run();
service.serviceMethodA("b", "B");
}
}
}
class MyService1 {
private String userName, userPassWord;
String s = new String();
public void serviceMethodA(String userName, String userPassWord) {
synchronized (s) {
try {
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入同步块");
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开同步块");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果如下：从代码上可以看到，线程A和线程B访问的都是service这个对象，所以“对象监控器”为同一个对象，理论上，在这种情况，执行的结果应该是同步的，从控制台打印的结果来看，也确实是同步的。
那么synchronized(非this对象)有什么优点呢，我们假设在一个类中有很多synchronized修饰的方法，虽然可以实现同步，但是同时也形成了阻塞，这样就影响了运行效率，但是使用同步代码块非this锁就可以解决这个问题，因为非this锁和this锁是异步的，他们之间不会互相争夺锁，这样运行效率就提高了。下面看一个例子来证明这件事情，只需要在MyService1类里添加一个方法即可，然后线程B调用该方法。代码如下：
public void serviceMethodB(String userName, String userPassWord) {
synchronized (this) {
try {
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入同步块");
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开同步块");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果如下：由于“对象监视器”不同，所以运行的结果是异步的，这个异步说的是方法serviceMethodA和方法serviceMethodB之间是异步的，交叉执行的。
上面说过了多个线程同时访问synchronized(非this对象)代码块时，呈同步效果，也就是说必须一个线程执行完释放掉锁，另一个线程才可以执行。也说过了多个线程分别访问this锁和非this锁，呈异步效果，可以提高运行效率。接下来说一说多线程访问不同的对象是什么效果，也就是使用不同的“对象监视器”。下面看一个例子，代码如下：
public static void main(String[] args) {
MyService4 service = new MyService4();
MyObject1 object = new MyObject1();
MyObject1 object1 = new MyObject1();
//两个线程传入不同的对象
ThreadA a = new ThreadA(service, object);
a.setName("A");
ThreadB b = new ThreadB(service, object1);
b.setName("B");
a.start();
b.start();
}
public static class ThreadA extends Thread {
private MyService4 service;
private MyObject1 object;
public ThreadA(MyService4 service, MyObject1 object) {
super();
this.service = service;
this.object = object;
}
@Override
public void run() {
super.run();
service.serviceMethod(object);
}
}
public static class ThreadB extends Thread {
private MyService4 service;
private MyObject1 object;
public ThreadB(MyService4 service, MyObject1 object) {
super();
this.service = service;
this.object = object;
}
@Override
public void run() {
super.run();
service.serviceMethod(object);
}
}
}
class MyService4 {
public void serviceMethod(MyObject1 object) {
synchronized (object) {
try {
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入同步块");
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开同步块");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MyObject1 {
}
运行结果如下：由结果可以看出来，如果使用不同的“对象监视器”，结果是异步执行的。
