java synchronized详解（1）

关注

转载最新推荐文章于 2026-05-18 09:43:40 发布 225 阅读 AI 写同款· GEO 优化 ›

深入解析Java中的synchronized关键字接下来是偏向锁，我们还是用同样的代码即可，需要注意的是偏向锁必须在jvm启动后的一段时间才会运行，所以如果我们想打印偏向锁必须让线程休眠那么几秒，这里笔者就偷懒了一下，通过设置jvm参数。打印结果如下，我们只需关注第一行的object header，可以看到第一列的00000001，我们看到后3位为001，偏向锁标记为0，锁标记为01，001这就是我们说的无锁状态。上文讲解锁升级的之后，我们一直在说对象头的概念，所以为了能够直观的看到锁对象中对象头锁标记和锁状态的变化，我们这里引入一个jol工具。阅读详情

java synchronized详解（1）

2018-02-23 Java知音

点击上方“Java知音”，选择“置顶公众号”

技术文章第一时间送达！

知音专栏

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

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

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

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

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

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

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

package ths;

public class Thread1 implements Runnable {  
    public void run() {  
         synchronized(this) {  
              for (int i = 0; i < 5; i++) {  
                   System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
              }  
         }  
    }  
    public static void main(String[] args) {  
         Thread1 t1 = new Thread1();  
         Thread ta = new Thread(t1, "A");  
         Thread tb = new Thread(t1, "B");  
         ta.start();  
         tb.start();  
    } 
}

结果：
     A synchronized loop 0
     A synchronized loop 1
     A synchronized loop 2
     A synchronized loop 3
     A synchronized loop 4
     B synchronized loop 0
     B synchronized loop 1
     B synchronized loop 2
     B synchronized loop 3
     B synchronized loop 4

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

package ths;

public class Thread2 {  
    public void m4t1() {  
         synchronized(this) {  
              int i = 5;  
              while( i-- > 0) {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try {  
                        Thread.sleep(500);  
                   } catch (InterruptedException ie) {  
                   }  
              }  
         }  
    }  
    public void m4t2() {  
         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 Thread2 myt2 = new Thread2();  
         Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  );  
         Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  );  
         t1.start();  
         t2.start();  
    } 
}

结果：
     t1 : 4
     t2 : 4
     t1 : 3
     t2 : 3
     t1 : 2
     t2 : 2
     t1 : 1
     t2 : 1
     t1 : 0
     t2 : 0

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

//修改Thread2.m4t2()方法：  
    public void m4t2() {  
         synchronized(this) {  
              int i = 5;  
              while( i-- > 0) {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try {  
                        Thread.sleep(500);  
                   } catch (InterruptedException ie) {  
                   }  
              }  
         }

    }

结果：

     t1 : 4
     t1 : 3
     t1 : 2
     t1 : 1
     t1 : 0
     t2 : 4
     t2 : 3
     t2 : 2
     t2 : 1
     t2 : 0

//修改Thread2.m4t2()方法如下：

    public synchronized void m4t2() {  
         int i = 5;  
         while( i-- > 0) {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try {  
                   Thread.sleep(500);  
              } catch (InterruptedException ie) {  
              }  
         }  
    }

结果：
     t1 : 4
     t1 : 3
     t1 : 2
     t1 : 1
     t1 : 0
     t2 : 4
     t2 : 3
     t2 : 2
     t2 : 1
     t2 : 0

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

package ths;

public class Thread3 { 
    class Inner { 
         private void m4t1() { 
              int i = 5; 
              while(i-- > 0) { 
                   System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i); 
                   try { 
                        Thread.sleep(500); 
                   } catch(InterruptedException ie) { 
                   } 
              } 
         } 
         private void m4t2() { 
              int i = 5; 
              while(i-- > 0) { 
                   System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); 
                   try { 
                        Thread.sleep(500); 
                   } catch(InterruptedException ie) { 
                   } 
              } 
         } 
    } 
    private void m4t1(Inner inner) { 
         synchronized(inner) { //使用对象锁 
         inner.m4t1(); 
    } 
    private void m4t2(Inner inner) { 
         inner.m4t2(); 
    } 
    public static void main(String[] args) { 
         final Thread3 myt3 = new Thread3(); 
         final Inner inner = myt3.new Inner(); 
         Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1"); 
    Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2"); 
    t1.start(); 
    t2.start(); 
 } 
}

结果：

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

     t1 : Inner.m4t1()=4
     t2 : Inner.m4t2()=4
     t1 : Inner.m4t1()=3
     t2 : Inner.m4t2()=3
     t1 : Inner.m4t1()=2
     t2 : Inner.m4t2()=2
     t1 : Inner.m4t1()=1
     t2 : Inner.m4t2()=1
     t1 : Inner.m4t1()=0
     t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized：

private synchronized void m4t2() {  
    int i = 5;  
    while(i-- > 0) {  
         System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);  
         try {  
              Thread.sleep(500);  
         } catch(InterruptedException ie) {  
         }  
    }  
}

结果：

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。

     t1 : Inner.m4t1()=4
     t1 : Inner.m4t1()=3
     t1 : Inner.m4t1()=2
     t1 : Inner.m4t1()=1
     t1 : Inner.m4t1()=0
     t2 : Inner.m4t2()=4
     t2 : Inner.m4t2()=3
     t2 : Inner.m4t2()=2
     t2 : Inner.m4t2()=1
     t2 : Inner.m4t2()=0