03.Java 多线程 - synchronized

基本概念

synchronized 的定义：

• 字面的意思是同步，也称为锁、同步锁。

synchronized 的作用：

• 它保证了同一时间，多个线程在访问某个对象时，有且只有一个线程可以操作该对象。即不同线程对同步锁的访问是互斥的。

synchronized 的理解：

• 好比厕所，每次只能一个人使用。一旦被占用，而其他人必须在外面等待。而 synchronized 就是厕所的锁，一旦上锁，其他人无法访问。

---

作用范围

synchronized 只对对象生效，但是作用的范围可以是一段代码（代码块），也可以是整个方法。

---

1.修饰代码块

synchronized 修饰代码块时。这时候对象可以有三种形式

• 使用成员变量替代对象，如果是静态成员变量代表作用在该类的所有对象。

class MyRunnable implements Runnable {    private byte[] lock = new byte[0];     public void run() {        synchronized (lock) {            //dosomething...        }}

• 使用 this 关键字，代表作用在该类的一个对象上。

class MyRunnable implements Runnable {    public void run() {        synchronized (this) {            //dosomething...        }}

• 使用类，表示作用在该类的所有对象

class MyRunnable implements Runnable {    public void run() {        synchronized (MyRunnable.class) {            //dosomething...        }}

---

2.修饰方法

synchronized 也可以修饰方法，包括静态方法与非静态方法。

• 作用在非静态方法上，只对该类的一个对象生效

class MyRunnable implements Runnable {    public synchronized void print() {        //dosomething...    }    public void run() {        print();    }}

• 作用在静态方法上，对该类的所有对象生效

class MyRunnable implements Runnable {    public synchronized static void print() {        //dosomething...    }    public void run() {        print();    }}

---

实例探究

1.synchronized 作用对象

synchronized 只能作用在对象上，到使其生效的前提是作用在同一个对象。

首先来看 synchronized 失效的例子：

// 线程public class MyThread extends Thread {    public void print() {        synchronized (this) {            for (int i = 0; i < 3; i++) {                System.out.println(this.getName() + "- print -" + i);            }        }    }    public void run() {        print();    }}// 调用MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.start();t2.start();t3.start();// 结果：// Thread-0- print -0// Thread-1- print -0// Thread-0- print -1// Thread-1- print -1// Thread-0- print -2// Thread-1- print -2// Thread-2- print -0// Thread-2- print -1// Thread-2- print -2

观察输出结果，发现同一时间段存在多个线程访问同步代码块，说明 synchronized 失效 ：

• 这里使用 this 关键字表示 Mythread 的对象，准确来讲是一个对象。

• 在调用过程中，Mythread 类创建了几个不同的对象。

• synchronized 之所以生效，就是因为它锁住的是 Mythread 类各自的对象，它们之间是相互不干扰的。

---

下面来探究要如何修正它，既然 synchronized 作用的是不同的对象，那么让它作用同一对象，效果自然就出来了。这里有四种方式：

• 使用 Runnable 代替 Thread 。此时 this 代表的是 MyRunnable 类的对象，而调用时所有的线程都访问了同一个 MyRunnable 对象。

  // 线程public class MyRunnable implements Runnable {    public void run() {        synchronized (this) {            print();        }    }    // 省略代码...}// 调用Thread t1 = new Thread(mr,"t1");Thread t2 = new Thread(mr,"t2");Thread t3= new Thread(mr,"t3");t1.start();t2.start();t3.start();

---

• 将 print 修改为静态方法。 synchronized 修饰静态方法时，是作用在该类的所有对象上。

  public class MyThread extends Thread {    // 省略部代码...    public synchronized static void print() {        // do something...    }}

---

• 将 this 修改为全局变量，原理同上。

  public class MyThread extends Thread {    // 省略代码...    private static byte [ ] lock = new byte[0];    public void print() {        synchronized (lock) {            // do something...        }    }}

---

• 将 this 修改为类，synchronized 修饰类时，代表作用在该类的所有对象上。

  public class MyThread extends Thread {    // 省略代码...    public  void print() {        synchronized (MyThread.class) {            // do something...        }    }}

---

2. synchronized 方法继承

synchronized 关键字不能被继承的，因为它并不属于方法的一部分。

在父类中的某个方法使用了 synchronized 关键字，而在子类覆写了该方法，在子类中的这个方法默认情况下并不是同步的。

如果子类也想要实现同步效果，可以采取以下两种方式：

• 显示地加上 synchronized 关键字

  // 父类public class Parent {   public synchronized void method() { }}// 子类：显示地加上 synchronized 关键字public class Child extends Parent {   public synchronized void method() { }}

• 直接调用父类的方法

  public class Child extends Parent {   public void method() {        super.method();      }} 

---

3. 同步方法 & 未同步方法

在一个类中，访问 synchronized 修饰的代码块或方法时：

• 其他被 synchronized 修饰的代码块或方法也将被锁住。

• 其他不被 synchronized 修饰的代码块或方法则可以正常访问。

public class MyRunnable implements Runnable {    public synchronized void talk() {        for (int i = 0; i < 3; i++) {            System.out.println(Thread.currentThread().getName() + "-print-" + i);        }    }    public void say() {        synchronized (this) {            for (int i = 0; i < 3; i++) {                System.out.println(Thread.currentThread().getName()  + "-say-" + i);            }        }    }    public void read() {        for (int i = 0; i < 3; i++) {            System.out.println(Thread.currentThread().getName()  + "-read-" + i);        }    }    public void run() {        talk();        say();        read();    }}// 调用：MyRunnable mr = new MyRunnable();Thread t1 =new Thread(mr,"t1");Thread t2 =new Thread(mr,"t2");Thread t3 =new Thread(mr,"t3");t1.start();t2.start();t3.start();

• 结果如下

// 结果：t1-print-0t1-print-1t1-print-2t1-say-0t1-say-1t1-say-2t1-read-0t1-read-1t1-read-2t3-print-0t3-print-1t3-print-2t3-say-0t3-say-1t3-say-2t3-read-0 // 关键t2-print-0t2-print-1t2-print-2t2-say-0t2-say-1t3-read-1t3-read-2t2-say-2t2-read-0t2-read-1t2-read-2

---

参考

• http://wangkuiwu.github.io/2012/08/04/threads-basic/