Java多线程之synchronized-优快云博客

本文通过三个测试类详细解析了Java中synchronized关键字的应用场景，包括同步方法、静态同步方法及同步块的使用方式与特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这里通过三个测试类阐述了synchronized应用的不同场景

首先是最基本的synchronized Method的使用

packagecom.jadyer.thread.sync;
/**
*SynchronizedMethodTest
*@see===================================================================================================
*@see概述：Java中的每个对象都有一个锁(lock)或者叫做监视器(monitor)
*@see说明：当synchronized关键字修饰一个方法时，则该方法为同步方法
*@see当某个线程访问某个对象的synchronized方法时，则表示将该对象上锁
*@see此时其它的任何线程，均无法访问该对象中的任何一个synchronized方法(但允许访问该对象中的非synchronized方法)
*@see直到该线程所访问的synchronized方法执行完毕(或者抛出了异常)之后，该对象的锁才会被释放
*@see此时其它的任何线程，才被允许访问该synchronized方法，或者是该对象中的其它synchronized方法
*@see===================================================================================================
*@see总结：如果一个对象有多个synchronized方法，某一时刻某个线程已经执行了该对象中的某一个synchronized方法
*@see那么在该方法没有执行完毕之前，其它线程是无法访问该对象中的，包括该方法在内的，任何一个synchronized方法
*@see重点在于判断Synchronized锁的是谁。如果该方法是静态的，则锁Class对象，否则锁的就是当前对象
*@see===================================================================================================
*@see补充：1)这只是针对多个线程操作同一个类的同一个对象的情况。www.linuxidc.com若多个线程操作同一个类的不同对象，则不存在这种情况
*@see2)Java中的volatile变量也可以看作是一种"程度较轻的synchronized"
*@see关于volatile的更多信息，请参考http://www.ibm.com/developerworks/cn/java/j-jtp06197.html
*@see备注：实际项目中，用到的更多的还是JDK5.0开始推出的Java并发包，即java.util.concurrent包里面的工具类
*@seejava.util.concurrent可以非常细粒度的实现并发。比如线程访问到了一个已被锁的对象，它可以让这个线程等到10秒
*@see10秒后如果该对象仍未被解锁，那么就可以返回给用户超时的提示等，而如果使用synchronized则是无法这么精确控制的
*@see===================================================================================================
*@see注意：1)当synchronized方法执行完或者发生异常时，会自动释放锁
*@see2)被synchronized保护的数据应该是private的，否则也就没必要去通过方法来访问这个public的数据了
*@see===================================================================================================
*@author宏宇
*@createFeb21,20125:29:39PM
*/
publicclassSynchronizedTest{
publicstaticvoidmain(String[]args){
Bankbank=newBank();
Threadtt11=newThread(newThreadRMB(bank));
//new一个新的Bank对象。此时存在两个Bank对象，并且它们属于同一个类的不同的对象
//如要验证多个线程操作同一个类的不同的对象的synchronized方法，只需取消注释该行代码即可
//bank=newBank();
Threadtt22=newThread(newThreadDollar(bank));
tt11.start();
tt22.start();
}
}
classThreadRMBimplementsRunnable{
privateBankbank;
publicThreadRMB(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getRMB();
}
}
classThreadDollarimplementsRunnable{
privateBankbank;
publicThreadDollar(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getDollar();
}
}
classBank{
publicsynchronizedvoidgetRMB(){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
publicsynchronizedvoidgetDollar(){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}

下面演示的是synchronized static Method的使用

packagecom.jadyer.thread.sync;
/**
*SynchronizedStaticMethodTest
*@see说明：如果某个synchronized方法是static的
*@see那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是该方法所在的对象所对应的Class对象
*@see因为Java中无论一个类有多少个对象，这些对象都会对应唯一的一个Class对象
*@see因此当线程分别访问同一个类的两个对象的两个static的synchronized方法时，它们的执行顺序也是顺序执行的
*@see即一个线程先执行一个static的synchronized方法，执行完毕后，另一个线程才开始执行另一个static的synchronized方法
*@see总结：重点在于判断synchronized锁的是谁。www.linuxidc.com如果该方法是静态的，则锁Class对象，否则锁的就是当前对象
*@author宏宇
*@createFeb21,20125:29:39PM
*/
publicclassSynchronizedStaticTest{
publicstaticvoidmain(String[]args){
Bankbank=newBank();
Threadtt11=newThread(newThreadRMB(bank));
Threadtt22=newThread(newThreadDollar(bank));
tt11.start();
tt22.start();
}
}
classThreadRMBimplementsRunnable{
privateBankbank;
publicThreadRMB(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getRMB();
}
}
classThreadDollarimplementsRunnable{
privateBankbank;
publicThreadDollar(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getDollar();
}
}
classBank{
//如要验证synchronized锁同一个类的对象，和锁它的Class对象的区别
//可去掉static关键字，再查看控制台打印，即publicsynchronizedvoidgetRMB()
publicsynchronizedstaticvoidgetRMB(){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
publicsynchronizedstaticvoidgetDollar(){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}

最后演示的是synchronized Block的使用

packagecom.jadyer.thread.sync;
/**
*SynchronizedBlockTest
*@author宏宇
*@createFeb21,20125:29:39PM
*/
publicclassSynchronizedBlockTest{
publicstaticvoidmain(String[]args){
Bankbank=newBank();
Threadtt11=newThread(newThreadRMB(bank));
//如果要验证synchronized(this)锁的是当前类的对象，而非当前类的Class对象
//则可取消注释该行代码，再观察控制台打印效果。效果应该是两个线程并发执行的输出
//bank=newBank();
Threadtt22=newThread(newThreadDollar(bank));
tt11.start();
tt22.start();
}
}
classThreadRMBimplementsRunnable{
privateBankbank;
publicThreadRMB(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getRMB();
}
}
classThreadDollarimplementsRunnable{
privateBankbank;
publicThreadDollar(Bankbank){
this.bank=bank;
}
@Override
publicvoidrun(){
bank.getDollar();
}
}
/**
*Bank
*@see说明：synchronized块的写法：synchronized(object){//TODO...}，它表示线程在执行的时候，会对object对象上锁
*@see通常会把java.lang.Object对象传进来，事实上这里可以传进来任何的对象
*@see因为它是一个没有实际作用的对象，其仅仅起到锁的作用，就像一个标识一样
*@see作用：它表示，如果线程能够进入到这里，即执行到这里，那么，就将object对象锁上
*@see如果另一个线程也执行到这里，发现object对象已上锁，则会等待其解锁后，才会去执行synchronized块里面的代码
*@see补充：synchronized(this)表示对当前类的对象上锁。注意，它锁的不是当前类的Class对象
*@seesynchronized(Bank.class)表示对当前类的Class对象上锁
*@author宏宇
*@createFeb22,20122:29:16AM
*/
classBank{
privateObjectobj11=newObject();
privateObjectobj22=newObject();
publicvoidgetRMB(){
//synchronized(obj11){
synchronized(Bank.class){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
publicvoidgetDollar(){
//synchronized(obj11){
//synchronized(obj22){
synchronized(this){
for(inti=0;i<20;i++){
try{
Thread.sleep((long)(Math.random()*1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}