java多线程之-----静态同步synchronized方法与synchronized（class） 代码块

这个也是我在面试中被问到的一个题目（synchronize修饰静态方法和非静态方法的区别），这个没答出来

关键字synchronized还可以应用在static静态方法上，如果这样写，那是对当前的*.java文件对应的Class类进行持锁，测试项目：类文件Service.java代码如下：

public class Service {
synchronized public static void PrintA(){
try {
System.out.println("线程的名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入printA");
Thread.sleep(3000);
System.out.println("线程的名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开printA");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
synchronized public static void PrintB(){

System.out.println("线程的名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入printB");
System.out.println("线程的名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开printB");

}
}

ThreadA的代码：

public class ThreadA extends Thread{

@Override
public void
4000
run() {
// TODO Auto-generated method stub
super.run();
Service.PrintA();
}

}

ThreadB：

public class ThreadB extends Thread{

@Override
public void run() {
// TODO Auto-generated method stub
super.run();
Service.PrintB();
}

}

运行测试代码：

public class Test1 {
public static void main(String[] args) throws InterruptedException {
ThreadA a = new ThreadA();
a.setName("A");
a.start();
ThreadB b = new ThreadB();
b.setName("B");
b.start();

}
}

运行结果：



从运行结果来看，并没有什么特别地方，都是同步的效果，和将synchronized关键字加到非静态static方法上使用的效果是一样的，其实还是有本质上的不同，synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁：

为了验证不是同一个锁。创建新的 项目，Service.java的代码如下：

public class Service {
synchronized public static void PrintA() {
try {
System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入printA");
Thread.sleep(3000);
System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开printA");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

synchronized public static void PrintB() {
System.out.println("线程的名称为：" + Thread.currentThread().getName() + "在"
+ System.currentTimeMillis() + "进入printB");

System.out.println("线程的名称为：" + Thread.currentThread().getName() + "在"
+ System.currentTimeMillis() + "离开printB");
}

synchronized public void PrintC() {
System.out.println("线程的名称为：" + Thread.currentThread().getName() + "在"
+ System.currentTimeMillis() + "进入printB");
System.out.println("线程的名称为：" + Thread.currentThread().getName() + "在"
+ System.currentTimeMillis() + "离开printB");

}
}

ThreadA ：

public class ThreadA extends Thread{
private Service service;
public ThreadA(Service service) {
// TODO Auto-generated constructor stub
super();
this.service = service;
}
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
service.PrintA();
}

}

ThreadB:

public class ThreadB extends Thread{
private Service service;
public ThreadB(Service service) {
// TODO Auto-generated constructor stub
super();
this.service = service;
}
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
service.PrintB();
}

}

ThreadC:

public class ThreadC extends Thread{
private Service service;
public ThreadC(Service service) {
// TODO Auto-generated constructor stub
super();
this.service = service;
}
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
service.PrintC();
}

}

测试代码类：

public class Test1 {
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
ThreadA a = new ThreadA(service);
a.setName("A");
a.start();
ThreadB b = new ThreadB(service);
b.setName("B");
b.start();
ThreadC c = new ThreadC(service);
c.setName("C");
c.start();

}
}

运行结果：



结果产生异步的原因是持有不同的锁，一个是对象锁，一个是Class锁，而Class锁可以对类的所有对象实例起作用。如果不是Class锁的话，则多个实例就有多个锁，上文章有说到。下面验证Class锁对所有的实例起作用

修改运行测试文件如下：

public class Test1 {
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
Service service2 = new Service();
ThreadA a = new ThreadA(service);
a.setName("A");
a.start();
ThreadB b = new ThreadB(service2);
b.setName("B");
b.start();

}
}

运行结果：



由结果来看，依然是同步进行的，也就是说明了Class锁对所有实例起作用。

同步Synchronized（class） 的实质其实和synchronized static 方法一样，都是给Class加锁。验证：

修改Service代码：

public class Service {
public void PrintA() {
synchronized (Service.class) {
try {
System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入printA");
Thread.sleep(3000);
System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开printA");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

public  void PrintB() {
synchronized (Service.class) {
System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入printB");

System.out.println("线程的名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开printB");
}
}
}

注意：PrintA和PrintB方法加不加static都一样了这时
再次运行代码得：

结论：静态同步synchronized方法与synchronized（class）代码块效果一样，没有本质上的区别，与非静态的方法比起来，非静态的是给对象上锁。多个对象的时候会给多个对象上锁。依旧是异步的。而静态的方法，则因为持有的是Class锁，所以多个对象创建的时候，因为其Class依旧是一样的，所有就会是同步状态