Java多线程并发编程 Synchronized关键字

synchronized 关键字解析

同步锁依赖于对象，每个对象都有一个同步锁。

现有一成员变量 Test，当线程 A 调用 Test 的 synchronized 方法，线程 A 获得 Test 的同步锁，同时，线程 B 也去调用 Test 的 synchronized 方法，此时线程 B 无法获得 Test 的同步锁，必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码。

综上，正确使用 synchronized 关键字可确保原子性。

synchronized 关键字的特性应用

特性 1：

当线程 A 调用某对象的synchronized 方法或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的synchronized 方法或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。

DEMO1，synchronized 方法：

public class Test {

  private static class Counter {

    public synchronized void count() {
      for (int i = 0; i < 6; i++) {
        System.out.println(Thread.currentThread().getName() + "， i = " + i);
      }
    }

  }

  private static class MyThread extends Thread {

    private Counter mCounter;

    public MyThread(Counter counter) {
      mCounter = counter;
    }

    @Override
    public void run() {
      super.run();
      mCounter.count();
    }
  }

  public static void main(String[] var0) {
    Counter counter = new Counter();
    // 注：myThread1 和 myThread2 是调用同一个对象 counter
    MyThread myThread1 = new MyThread(counter);
    MyThread myThread2 = new MyThread(counter);
    myThread1.start();
    myThread2.start();
  }

}

DEMO1 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1， i = 0
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-1， i = 4
Thread-1， i = 5

DEMO2，synchronized 代码块：

public class Test {

  private static class Counter {

    public void count() {
      synchronized (this) {
        for (int i = 0; i < 6; i++) {
          System.out.println(Thread.currentThread().getName() + "， i = " + i);
        }
      }
    }
  }

  private static class MyThread extends Thread {

    private Counter mCounter;

    public MyThread(Counter counter) {
      mCounter = counter;
    }

    @Override
    public void run() {
      super.run();
      mCounter.count();
    }
  }

  public static void main(String[] var0) {
    Counter counter = new Counter();
    MyThread myThread1 = new MyThread(counter);
    MyThread myThread2 = new MyThread(counter);
    myThread1.start();
    myThread2.start();
  }
}

DEMO2 输出：

Thread-0， i = 0
Thread-0， i = 1
Thread-0， i = 2
Thread-0， i = 3
Thread-0， i = 4
Thread-0， i = 5
Thread-1， i = 0
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-1， i = 4
Thread-1， i = 5

可见，当同步锁未释放时，其他线程将被阻塞，直至获得同步锁。

而且 DEMO1 和 DEMO2 的输出结果是一样的，synchronized 方法和 synchronized 代码块的不同之处在于 synchronized 方法作用域较大，作用于整个方法，而 synchronized 代码块可控制具体的作用域，更精准控制提高效率。（毕竟阻塞的都是时间啊）

DEMO3，仅修改 main 方法：

public static void main(String[] var0) {
    // 注意：myThread1 和 myThread2 传入的 Counter 是两个不同的对象
    MyThread myThread1 = new MyThread(new Counter());
    MyThread myThread2 = new MyThread(new Counter());
    myThread1.start();
    myThread2.start();
  }

DEMO3 输出：

Thread-0， i = 0
Thread-1， i = 0
Thread-0， i = 1
Thread-1， i = 1
Thread-1， i = 2
Thread-1， i = 3
Thread-0， i = 2
Thread-1， i = 4
Thread-0， i = 3
Thread-1， i = 5
Thread-0， i = 4
Thread-0， i = 5

同步锁基于对象，只要锁的来源一致，即可达到同步的作用。所以，但对象不一样，则不能达到同步效果。

特性 2：

当线程 A 调用某对象的synchronized 方法或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的其他 synchronized 方法或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。（注意：重点是其他）

DEMO4，仅修改 doOtherThings 方法的修饰：

public class Test {

  private static class Counter {

    public synchronized void count() {
      System.out.println(Thread.currentThread().getName() + " sleep");
      try {
        Thread.sleep(3000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + " awake");
    }

    public synchronized void doOtherThings(){
      System.out.println(Thread.currentThread().getName() + " doOtherThings");
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThings();
      }
    }).start();
  }
}

DEMO4 输出：

Thread-0 sleep
Thread-0 awake
Thread-1 doOtherThings

可见，synchronized 获得的同步锁并非仅仅锁住代码，而是锁住整个对象。

此时应提及 happens-before 原则，正因 happens-before 原则的存在才有此现象的发生。
happens-before 原则的其中一条：
管理锁定原则：一个 unLock 操作先行发生于后面对同一个锁的 lock 操作。
（此处暂不作过多解释，解释起来能再写一篇文章了）

DEMO5，仅修改 doOtherThings 方法：

public void doOtherThings(){
      synchronized (this){
        System.out.println(Thread.currentThread().getName() + " doOtherThings");
      }
    }

DEMO5 输出：

Thread-0 sleep
Thread-0 awake
Thread-1 doOtherThings

DEMO4 和 DEMO5 的输出结果竟然一致！没错，因为他们的同步锁来源一致（都是本实例自己），所以可以达到同步效果。

// 这两个 synchronized 锁的是同一个对象
public synchronized void count(){};
public void doOtherThings(){
    synchronized (this){}
}

DEMO6，去掉 doOtherThings 方法的同步关键字：

public void doOtherThings(){
      System.out.println(Thread.currentThread().getName() + " doOtherThings");
    }

DEMO6 输出：

Thread-0 sleep
Thread-1 doOtherThings
Thread-0 awake

当线程 A 调用某对象的synchronized 方法或者 synchronized 代码块时，无论同步锁是否释放，其他线程调用同一对象的其他非 synchronized 方法或者非 synchronized 代码块时可立即调用。

实例锁和全局锁

以上 DEMO 实现的都是实例锁。锁住（作用域）的是具体某一对象实例。

什么是全局锁？
锁住整个 Class，而非某个对象或实例。

注：单例型的实例锁不属于全局锁。

全局锁的实现：

静态 synchronized 方法

DEMO7：

public class Test {

  private static class Counter {

    public static synchronized void count() {
      System.out.println(Thread.currentThread().getName() + " sleep");
      try {
        Thread.sleep(3000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + " awake");
    }

    public static synchronized void doOtherThings(){
      System.out.println(Thread.currentThread().getName() + " doOtherThings");
    }
  }

  public static void main(String[] var0) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        Counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        Counter.doOtherThings();
      }
    }).start();
  }
}

DEMO7 输出：

Thread-0 sleep
Thread-0 awake
Thread-1 doOtherThings

static 声明的方法为全局方法，与对象实例化无关，所以 static synchronized 方法为全局同步方法，与对象实例化无关。

synchronized 具体 Class 的代码块

DEMO8：

public class Test {

  private static class Counter {

    public static synchronized void count() {
      System.out.println(Thread.currentThread().getName() + " sleep");
      try {
        Thread.sleep(3000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + " awake");
    }

    public void doOtherThings(){
      synchronized (Counter.class){
        System.out.println(Thread.currentThread().getName() + " doOtherThings");
      }
    }
  }

  public static void main(String[] var0) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        Counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        Counter counter = new Counter();
        counter.doOtherThings();
      }
    }).start();
  }
}

DEMO8 输出：

Thread-0 sleep
Thread-0 awake
Thread-1 doOtherThings

synchronized (Counter.class) 获得的同步锁是全局的，static synchronized 获得的同步锁也是全局的，同一个锁，所以达到同步效果。

区分 synchronized (this) 与 synchronized (Class.class)

DEMO9：

public class Test {

  private static class Counter {

    public void count() {
      synchronized (this){
        System.out.println(Thread.currentThread().getName() + " sleep");
        try {
          Thread.sleep(3000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " awake");
      }
    }

    public void doOtherThings(){
      synchronized (Counter.class){
        System.out.println(Thread.currentThread().getName() + " doOtherThings");
      }
    }
  }

  public static void main(String[] var0) {
    final Counter counter = new Counter();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.count();
      }
    }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        counter.doOtherThings();
      }
    }).start();
  }
}

DEMO9 输出：

Thread-0 sleep
Thread-1 doOtherThings
Thread-0 awake

synchronized (this) 获得的是具体对象实例 counter 的锁，而 synchronized (Counter.class) 获得的是全局锁，两把不同的锁，所以不能达到同步效果。

# Java # Synchronized # 关键字 # Java中synchronized用法汇总 # Java并发系列之JUC中的Lock锁与synchronized同步代码块问题 # Java中线程状态+线程安全问题+synchronized的用法详解 # Java中提供synchronized后为什么还要提供Lock # Java 深入浅出分析Synchronized原理与Callable接口 # Java对象级别与类级别的同步锁synchronized语法示例 # Java synchronized同步方法详解 # Java多线程之synchronized同步代码块详解 # Java多线程并发synchronized 关键字 # 的是 # 都是 # 锁住 # 时将 # 他们的 # 都有 # 这两个 # 才有 # 将被 # 而非 # 正因 # 不属于 # 能再 # 可以达到 # 时应 # 暂不 # 两把 # 也去 # 不同之处 # 写一篇

返回目录在线咨询

上一篇：稳定性与速度：如何评估建站服务器租用的服务质量？
下一篇：php怎么输入源码_php源码输入编辑与粘贴操作技巧

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

全网整合营销服务商

Java多线程并发编程 Synchronized关键字

您的项目需求