透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别

本文讲述了java中synchronized（对象锁）和static synchronized（类锁）的区别。分享给大家供大家参考，具体如下：

synchronized和static synchronized区别

通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。

下面的文章做了很好的总结：

1.synchronized与static synchronized 的区别

synchronized是对类的当前实例（当前对象）进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”， 类的两个不同实例就没有这种约束了。

那么static synchronized恰好就是要控制类的所有实例的并发访问，static synchronized是限制多线程中该类的所有实例同时访问jvm中该类所对应的代码块。实际上，在类中如果某方法或某代码块中有 synchronized，那么在生成一个该类实例后，该实例也就有一个监视块，防止线程并发访问该实例的synchronized保护块，而static synchronized则是所有该类的所有实例公用得一个监视块，这就是他们两个的区别。也就是说synchronized相当于 this.synchronized，而static synchronized相当于something.synchronized.（后面又讲解）

一个日本作者-结成浩的《java多线程设计模式》有这样的一个列子：

pulbic class something(){ 
 public synchronized void issynca(){} 
 public synchronized void issyncb(){} 
 public static synchronized void csynca(){} 
 public static synchronized void csyncb(){} 
} 

那么，假如有something类的两个实例x与y，那么下列各组方法被多线程同时访问的情况是怎样的？

a. x.issynca()与x.issyncb()
b. x.issynca()与y.issynca()
c. x.csynca()与y.csyncb()
d. x.issynca()与something.csynca()

这里，很清楚的可以判断：

a，都是对同一个实例（x）的synchronized域访问，因此不能被同时访问。（多线程中访问x的不同synchronized域不能同时访问)

如果在多个线程中访问x.issynca()，因为仍然是对同一个实例，且对同一个方法加锁，所以多个线程中也不能同时访问。（多线程中访问x的同一个synchronized域不能同时访问)

b，是针对不同实例的，因此可以同时被访问（对象锁对于不同的对象实例没有锁的约束）

c，因为是static synchronized，所以不同实例之间仍然会被限制,相当于something.issynca()与 something.issyncb()了，因此不能被同时访问。

那么，第d呢?，书上的 答案是可以被同时访问的，答案理由是synchronzied的是实例方法与synchronzied的类方法由于锁定（lock）不同的原因。

个人分析也就是synchronized 与static synchronized 相当于两帮派，各自管各自，相互之间就无约束了，可以被同时访问。

举个例子：

public class testsynchronized 
{ 
 public synchronized void test1() 
 { 
 int i = 5; 
 while( i-- > 0) 
 { 
 system.out.println(thread.currentthread().getname() + " : " + i); 
 try 
 { 
 thread.sleep(500); 
 } 
 catch (interruptedexception ie) 
 { 
 } 
 } 
 } 
 public static synchronized void test2() 
 { 
 int i = 5; 
 while( i-- > 0) 
 { 
 system.out.println(thread.currentthread().getname() + " : " + i); 
 try 
 { 
 thread.sleep(500); 
 } 
 catch (interruptedexception ie) 
 { 
 } 
 } 
 } 
 public static void main(string[] args) 
 { 
 final testsynchronized myt2 = new testsynchronized(); 
 thread test1 = new thread( new runnable() { public void run() { myt2.test1(); } }, "test1" ); 
 thread test2 = new thread( new runnable() { public void run() { testsynchronized.test2(); } }, "test2" ); 
 test1.start(); 
 test2.start(); 
// testrunnable tr=new testrunnable(); 
// thread test3=new thread(tr); 
// test3.start(); 
 } 
} 

test1 : 4 
test2 : 4 
test1 : 3 
test2 : 3 
test2 : 2 
test1 : 2 
test2 : 1 
test1 : 1 
test1 : 0 
test2 : 0 

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

结论：

a: synchronized static是某个类的范围，synchronized static csync{}防止多个线程中多个实例同时访问这个 类中的synchronized static 方法。它可以对类的所有对象实例起作用。

b: synchronized 是某实例的范围，synchronized issync(){}防止多个线程中这一个实例同时访问这个类的synchronized 方法。

其实总结起来很简单。

• 一个锁的是类对象，一个锁的是实例对象。
  
• 若类对象被lock，则类对象的所有同步方法全被lock；
  
• 若实例对象被lock，则该实例对象的所有同步方法全被lock。
  

2.synchronized方法与synchronized代码快的区别

synchronized methods(){} 与synchronized（this）{}之间没有什么区别，只是synchronized methods(){} 便于阅读理解，而synchronized（this）{}可以更精确的控制冲突限制访问区域，有时候表现更高效率。

两种方式效率比较：

1、同步块，代码如下：

import java.util.concurrent.countdownlatch; 
import java.util.concurrent.executorservice; 
import java.util.concurrent.executors; 
public class testsynchronized { 
 /** 
 * @param args 
 */ 
 public static void main(string[] args) { 
 executorservice service = executors.newcachedthreadpool(); 
 final countdownlatch cdorder = new countdownlatch(1); 
 final countdownlatch cdanswer = new countdownlatch(3); 
 final synchonizedclass sc = new synchonizedclass(); 
 for(int i=0; i<3; i++){ 
 runnable runnable = new runnable(){ 
 public void run() { 
 try{ 
 cdorder.await(); 
 sc.start(); 
 cdanswer.countdown(); 
 }catch(exception e){ 
 e.printstacktrace(); 
 } 
 } 
 }; 
 service.execute(runnable); 
 } 
 try{ 
 thread.sleep((long) (math.random()*10000)); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "发布执行命令"); 
 cdorder.countdown(); 
 long begintime = system.currenttimemillis(); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "已经发送命令，正在等待结果"); 
 cdanswer.await(); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "已收到所有响应结果,所用时间为：" + (system.currenttimemillis()-begintime)); 
 }catch(exception e){ 
 e.printstacktrace(); 
 } 
 service.shutdown(); 
 } 
} 
class synchonizedclass{ 
 public void start() throws interruptedexception{ 
 thread.sleep(100);//执行其它逻辑消耗时间 
 synchronized(this){ 
 system.out.println("我运行使用了 10 ms"); 
 } 
 } 
} 

运行结果如下：

线程main发布执行命令
线程main已经发送命令，正在等待结果
我运行使用了 10 ms
我运行使用了 10 ms
我运行使用了 10 ms
线程main已收到所有响应结果,所用时间为：110

同步方法，代码如下：

import java.util.concurrent.countdownlatch; 
import java.util.concurrent.executorservice; 
import java.util.concurrent.executors; 
public class testsynchronized { 
 /** 
 * @param args 
 */ 
 public static void main(string[] args) { 
 executorservice service = executors.newcachedthreadpool(); 
 final countdownlatch cdorder = new countdownlatch(1); 
 final countdownlatch cdanswer = new countdownlatch(3); 
 final synchonizedclass sc = new synchonizedclass(); 
 for(int i=0; i<3; i++){ 
 runnable runnable = new runnable(){ 
 public void run() { 
 try{ 
 cdorder.await(); 
 sc.start(); 
 cdanswer.countdown(); 
 }catch(exception e){ 
 e.printstacktrace(); 
 } 
 } 
 }; 
 service.execute(runnable); 
 } 
 try{ 
 thread.sleep((long) (math.random()*10000)); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "发布执行命令"); 
 cdorder.countdown(); 
 long begintime = system.currenttimemillis(); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "已经发送命令，正在等待结果"); 
 cdanswer.await(); 
 system.out.println("线程" + thread.currentthread().getname() + 
 "已收到所有响应结果,所用时间为：" + (system.currenttimemillis()-begintime)); 
 }catch(exception e){ 
 e.printstacktrace(); 
 } 
 service.shutdown(); 
 } 
} 
class synchonizedclass{ 
 public synchronized void start() throws interruptedexception{ 
 thread.sleep(100);//执行其它逻辑消耗时间 
// synchronized(this){ 
 system.out.println("我运行使用了 10 ms"); 
// } 
 } 
} 

运行结果如下：

线程main发布执行命令
线程main已经发送命令，正在等待结果
我运行使用了 10 ms
我运行使用了 10 ms
我运行使用了 10 ms
线程main已收到所有响应结果,所用时间为：332

两者相差：222ms。

 对比说明同步代码块比同步方法效率更高。

补充记忆：

1、synchronized关键字的作用域有二种：

1）是某个对象实例内，synchronized amethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；

2）是某个类的范围，synchronized static astaticmethod{}防止多个线程中不同的实例对象（或者同一个实例对象）同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}（或者synchronized(obj){/*区块*/}），它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；　

对synchronized(this)的一些理解（很好的解释了对象锁，注意其中的this关键字）　　

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。　

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。　　

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。　　

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。　　

五、以上规则对其它对象锁同样适用

补充一段代码，方便对synchronized关键字进行测试（简单修改即可）

public class testsynchronized 
{ 
 public void test1() 
 { 
 synchronized(this) 
 { 
 int i = 5; 
 while( i-- > 0) 
 { 
 system.out.println(thread.currentthread().getname() + " : " + i); 
 try 
 { 
 thread.sleep(500); 
 } 
 catch (interruptedexception ie) 
 { 
 } 
 } 
 } 
 } 
 public synchronized void test2() 
 { 
 int i = 5; 
 while( i-- > 0) 
 { 
 system.out.println(thread.currentthread().getname() + " : " + i); 
 try 
 { 
 thread.sleep(500); 
 } 
 catch (interruptedexception ie) 
 { 
 } 
 } 
 } 
 public synchronized void test3() 
 { 
 int i = 5; 
 while( i-- > 0) 
 { 
 system.out.println(thread.currentthread().getname() + " : " + i); 
 try 
 { 
 thread.sleep(500); 
 } 
 catch (interruptedexception ie) 
 { 
 } 
 } 
 } 
 public static void main(string[] args) 
 { 
 final testsynchronized myt2 = new testsynchronized(); 
 final testsynchronized myt3 = new testsynchronized(); 
 thread test1 = new thread( new runnable() { public void run() { myt2.test2(); } }, "test1" ); 
 thread test2 = new thread( new runnable() { public void run() { myt2.test3(); } }, "test3" ); 
 test1.start();; 
 test2.start(); 
 } 
} 

运行结果：

test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0
test3 : 4
test3 : 3
test3 : 2
test3 : 1
test3 : 0

下面我们着重介绍java中的 sychronized的用法，具体为：同步方法 与 同步块synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。　

1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：　

public synchronized void accessval(int newval);

synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

在 java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为static  synchronized ，以控制其对类的静态成员变量的访问。

synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 java 为我们提供了更好的解决办法，那就是 synchronized 块。　　

2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：　　

synchronized(syncobject) {
　　//允许访问控制的代码
　　}

synchronized 块是这样一个代码块，其中的代码必须获得对象 syncobject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

注意：

在使用synchronized关键字时候，应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法，因为synchronized程序块占有着对象锁，你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率，也不合逻辑。

同样，在同步程序块内调用yeild方法让出cpu资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。