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-0
t1-print-1
t1-print-2
t1-say-0
t1-say-1
t1-say-2
t1-read-0
t1-read-1
t1-read-2
t3-print-0
t3-print-1
t3-print-2
t3-say-0
t3-say-1
t3-say-2
t3-read-0 // 关键
t2-print-0
t2-print-1
t2-print-2
t2-say-0
t2-say-1
t3-read-1
t3-read-2
t2-say-2
t2-read-0
t2-read-1
t2-read-2

---

参考

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