synchronized详解

最新推荐文章于 2025-09-11 13:06:25 发布

weixin_33834679

最新推荐文章于 2025-09-11 13:06:25 发布

阅读量77

点赞数

CC 4.0 BY-SA版权

文章标签： java

原文链接：https://my.oschina.net/u/1774673/blog/811444

本文详细解析了Java中的synchronized关键字，包括其基本概念、应用场景、如何避免死锁等问题。通过多个示例展示了synchronized的不同用法，如修饰代码块、方法、静态方法等。

为什么80%的码农都做不了架构师？>>>

定义

synchronized 是 java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
以上规则对其它对象锁同样适用.

简单来说, synchronized就是为当前的线程声明一个锁, 拥有这个锁的线程可以执行区块里面的指令, 其他的线程只能等待获取锁, 然后才能相同的操作.

synchronized与死锁

这个很好用, 但是笔者遇到另一种比较奇葩的情况.

在同一类中，有两个方法是用了synchronized关键字声明
在执行其中一个方法的时候，需要等待另一个方法（异步线程回调）执行完，所以用了一个countDownLatch来做等待

代码解构如下：

synchronized void  a(){
  countDownLatch = new CountDownLatch(1);
  // do someing
  countDownLatch.await();
}

synchronized void b(){
     countDownLatch.countDown();
}

其中a方法由主线程执行, b方法由异步线程执行后回调.执行结果是:主线程执行 a方法后开始卡住, 不再往下做, 任你等多久都没用。这是一个很经典的死锁问题,a等待b执行，b也在等待a执行。为什么呢? 如果把以上代码转换一下，会好理解的多。

void  a(){
	synchronized(this){
		  countDownLatch = new CountDownLatch(1);
		  // do someing
		  countDownLatch.await();
	  }
	}

void b(){
	synchronized(this){
	     countDownLatch.countDown();
	    }
	}

synchronized 起了作用。此时主线程在a方法持有了对象锁，并且在等待子线程的b方法返回。然而b方法在等待主线程释放对象锁，然后才开始执行。死锁就这样产生了。

synchronized详解

正好遇到了这个问题，就借此机会全面了解一下synchronized关键字。

Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。——来自百度百科

synchronized用法

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象，也就是说当前执行该代码块的线程持有该对象的同步锁；
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象，同样也是当前执行该代码块的线程持有该对象的同步锁；
修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

先来看一个简单的多线程计数的例子。

public class SyncThread implements Runnable {
	private static int count=1;
    public void run() {  
         	int tmp=count;
              for (int i = 0; i < 2; i++) {
            	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                   System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
              } 
         count=tmp;
    }  
    public static void main(String[] args) {  
         SyncThread t1 = new SyncThread();  
         Thread ta = new Thread(t1, "A");  
         Thread tb = new Thread(t1, "B");  
         Thread tc = new Thread(t1, "C");  
         Thread td = new Thread(t1, "D");  
         Thread te = new Thread(t1, "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    } 
}

最简单，没有任何修饰的多线程计数器。每个线程往计数器计数两次，5个线程同时执行计数。我们预计的结果是count=10。执行一下，我们来看看结果。

A synchronized loop 1
D synchronized loop 1
E synchronized loop 1
C synchronized loop 1
B synchronized loop 1
D synchronized loop 2
A synchronized loop 2
B synchronized loop 2
C synchronized loop 2
E synchronized loop 2

最终结果count=2，线程执行的顺序也是混乱的，计数失败。

修饰一个代码块

现在我们使用synchronized关键字来修饰累加计数代码块。


public class SyncThread implements Runnable {
	private static int count=1;
    public void run() {  
         synchronized(this) {
         	int tmp=count;
              for (int i = 0; i < 2; i++) {
            	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                   System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
              } 
              count=tmp;
         }  
    }  
    public static void main(String[] args) {  
         SyncThread t1 = new SyncThread();  
         Thread ta = new Thread(t1, "A");  
         Thread tb = new Thread(t1, "B");  
         Thread tc = new Thread(t1, "C");  
         Thread td = new Thread(t1, "D");  
         Thread te = new Thread(t1, "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    } 
}

我们看到，最终结果count=10，线程的执行也是有顺序的，计数成功。使用synchronized关键字来修饰累加计数代码块后，一个线程访问同一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。也就是说多个线程是按照顺序排队执行计数代码块，同一时间只有一个线程在执行计数，多线程计数器实际变成了单线程计数。

我们再把SyncThread的调用稍微改一下：

    public static void main(String[] args) {
         Thread ta = new Thread(new SyncThread(), "A");  
         Thread tb = new Thread(new SyncThread(), "B");  
         Thread tc = new Thread(new SyncThread(), "C");  
         Thread td = new Thread(new SyncThread(), "D");  
         Thread te = new Thread(new SyncThread(), "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    }

此时的输出结果如下：

A synchronized loop 1
B synchronized loop 1
D synchronized loop 1
C synchronized loop 1
E synchronized loop 1
A synchronized loop 2
B synchronized loop 2
E synchronized loop 2
D synchronized loop 2
C synchronized loop 2

不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中5个线程同时在执行。这是因为synchronized只锁定对象，而上面例子中，5个线程都有各自的每个SyncThread 实例对象，每个线程都持有各自实例对象的锁，它们之间相互不影响，也就不会竞争同一个锁而产生阻塞。

synchronized关键字还可以指定要给某个对象加锁，如下：

/**
 * 银行账户类
 */
class Account {
   String name;
   float amount;

   public Account(String name, float amount) {
      this.name = name;
      this.amount = amount;
   }
   //存钱
   public  void deposit(float amt) {
      amount += amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
   //取钱
   public  void withdraw(float amt) {
      amount -= amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }

   public float getBalance() {
      return amount;
   }
}


/**
 * 账户操作类
 */
class AccountOperator implements Runnable{
   private Account account;
   public AccountOperator(Account account) {
      this.account = account;
   }

   public void run() {
      synchronized (account) {
         account.deposit(500);
         account.withdraw(200);
         System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
      }
   }
   
   public static void main(String args[]){
	   Account account = new Account("zhang san", 10000.0f);
	   AccountOperator accountOperator = new AccountOperator(account);

	   final int THREAD_NUM = 5;
	   Thread threads[] = new Thread[THREAD_NUM];
	   for (int i = 0; i < THREAD_NUM; i ++) {
	      threads[i] = new Thread(accountOperator, "Thread" + i);
	      threads[i].start();
	   }
   }
}

输出结果如下：

Thread0:10300.0
Thread4:10600.0
Thread3:10900.0
Thread2:11200.0
Thread1:11500.0

在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程获取到了account对象锁时，其他线程执行这段代码试图获取account对象锁时将会阻塞，直到该线程访问account对象结束。也就是说谁先拿到那个锁谁就可以运行它控制的这段代码，其他线程只有等它执行完这段代码，释放account对象锁之后，才有机会获取到锁，执行这段代码。当有一个明确的对象作为锁时，我们可以按照上面的做法，给这段代码加上synchronized关键字，并锁定account对象。但是当没有明确的对象作为锁，只是想让一段代码同步时，我们又该怎么办呢？可以创建一个特殊的对象来充当锁对象，代码如下：

class Test implements Runnable
{
   private byte[] lock = new byte[0];  // 特殊的instance变量
   public void method()
   {
      synchronized(lock) {
         // todo 同步代码块
      }
   }

   public void run() {

   }
}

说明：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

需要注意的是 synchronized(this) 与synchronized(count)锁的对象是不一样的，前者是在this对象加锁，而后者是count对象上加锁，所以这两个锁之间也不会有任何的影响。


public class SyncThread implements Runnable {
	private  Integer count=1;
    public void run() {
    	if(Thread.currentThread().getName().equals("B")||Thread.currentThread().getName().equals("D")){
    		lockCount();
    	}
    	else{
    		lockObj();
    	}
    }  
    
    public   void lockObj(){
    	synchronized(this){
        	int tmp=count;
             for (int i = 0; i < 2; i++) {
           	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                  System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
             } 
             count=tmp;
    	}
   
    } 
    
    public   void lockCount(){
    	synchronized(count){
        	int tmp=count;
             for (int i = 0; i < 2; i++) {
           	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                  System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
             } 
             count=tmp;
    	}
   
    } 
    public static void main(String[] args) {
    	SyncThread thread=new SyncThread();
         Thread ta = new Thread(thread, "A");  
         Thread tb = new Thread(thread, "B");  
         Thread tc = new Thread(thread, "C");  
         Thread td = new Thread(thread, "D");  
         Thread te = new Thread(thread, "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    } 
}

输出结果

B synchronized loop 1
A synchronized loop 1
A synchronized loop 2
B synchronized loop 2
E synchronized loop 3
D synchronized loop 3
E synchronized loop 4
D synchronized loop 4
C synchronized loop 5
C synchronized loop 6

线程A，C，E之间是顺序执行，B，D间也是顺序执行，说明synchronized(this) 与synchronized(count)锁定的目标不是同一个，也不会有任何的影响。

当没有明确的对象作为锁时，其实我们还有一种方法，使用Synchronized修饰一个方法。

修饰一个方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。计数器例子中SyncThread的run方法改成如下的方式，实现的效果一样。

public synchronized void run() {
	       	int tmp=count;
	           for (int i = 0; i < 2; i++) {
	         	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
	                System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
	           } 
	           count=tmp;
}

当前代码修饰的是一个方法，之前写法修饰的是一个代码块，这两种写法是等价的，都是锁定了整个方法的内容。

在用synchronized修饰方法时要注意以下几点：

在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
synchronized关键字不能继承。

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

修饰一个静态的方法

Synchronized也可修饰一个静态方法，用法如下：

public synchronized static void method() {
   // todo
}

我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。我们对计数器程序进行一些修改如下：


public class SyncThread implements Runnable {
	private static int count=1;
    public void run() {
    	mothed();
    }  
    
    public synchronized static void mothed(){
        	int tmp=count;
             for (int i = 0; i < 2; i++) {
           	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                  System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
             } 
             count=tmp;
   
    } 
    public static void main(String[] args) {
         Thread ta = new Thread(new SyncThread(), "A");  
         Thread tb = new Thread(new SyncThread(), "B");  
         Thread tc = new Thread(new SyncThread(), "C");  
         Thread td = new Thread(new SyncThread(), "D");  
         Thread te = new Thread(new SyncThread(), "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    } 
}

结果变成

A synchronized loop 1
A synchronized loop 2
C synchronized loop 3
C synchronized loop 4
D synchronized loop 5
D synchronized loop 6
E synchronized loop 7
E synchronized loop 8
B synchronized loop 9
B synchronized loop 10

5个线程分别执行各自SyncThread实例的mothed（）方法，与前面不一样的是，这次并发执行时却保持了线程同步。这是因为run中调用了synchronized 修饰的静态方法method，而静态方法是属于类的，所以五个SyncThread实例相当于用了同一把锁。

修饰一个类

我们把计数器再作一些修改。，使用synchronized 修饰SyncThread类。


public class SyncThread implements Runnable {
	private static int count=1;
    public void run() {
    	mothed();
    }  
    
    public  static void mothed(){
    	synchronized(SyncThread.class){
        	int tmp=count;
             for (int i = 0; i < 2; i++) {
           	  try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
                  System.out.println(Thread.currentThread().getName() + " synchronized loop " + tmp++);  
             } 
             count=tmp;
    	}
   
    } 
    public static void main(String[] args) {
         Thread ta = new Thread(new SyncThread(), "A");  
         Thread tb = new Thread(new SyncThread(), "B");  
         Thread tc = new Thread(new SyncThread(), "C");  
         Thread td = new Thread(new SyncThread(), "D");  
         Thread te = new Thread(new SyncThread(), "E");  
         ta.start();  
         tb.start();  
         tc.start();  
         td.start();  
         te.start();
    } 
}

结果和使用synchronized修饰mothed方法是一样的。

A synchronized loop 1
A synchronized loop 2
E synchronized loop 3
E synchronized loop 4
B synchronized loop 5
B synchronized loop 6
D synchronized loop 7
D synchronized loop 8
C synchronized loop 9
C synchronized loop 10

synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁。

总结

无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是类，该类所有的对象共用同一把锁。
每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制，或者使用更轻量级的锁来代替synchronized同步锁，如读写锁，volatile等。

转载于:https://my.oschina.net/u/1774673/blog/811444