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