@[toc]

线程八锁
通过线程八锁问题融会贯通synchronized关键字的使用 - 图1

凯有八门遁甲之术，你晓得线程八锁问题吗？赶紧来看一下吧~

1. 一锁

  1. class Number{
  2.     public synchronized void a() {
  3.         log.debug("1");
  4.     }
  5.     public synchronized void b() {
  6.         log.debug("2");
  7.     }
  8. }
  9. public static void main(String[] args) {
  10.     Number n1 = new Number();
  11.     new Thread(()->{ n1.a(); }, "t1").start();
  12.     new Thread(()->{ n1.b(); }, "t2").start();
  13. }

执行主方法，控制台的输出可能是2 1或是1 2。因为创建的两个线程在主方法中创建并启动，它们之间谁先能拿到CPU的使用权就谁先执行：

  • 如果t1先分到时间片，那么输出为1 2
  • 如果t2先分到时间片，那么输出为2 1

2. 二锁

  1. class Number{
  2.     public synchronized void a() {
  3.         sleep(1);  // 需先睡眠1s
  4.         log.debug("1");
  5.     }
  6.     public synchronized void b() {
  7.         log.debug("2");
  8.     }
  9. }
  10. public static void main(String[] args) {
  11.     Number n1 = new Number();
  12.     new Thread(()->{ n1.a(); }, "t1").start();
  13.     new Thread(()->{ n1.b(); }, "t2").start();
  14. }

情况和上面类似，可能的结果有：

  • 如果t1先分到时间片，那么输出情况为：等待1s输出1 2
  • 如果t2先分到时间片，那么输出情况为：先输出2，等待1s后输出1

3. 三锁

  1. class Number{
  2.     // a、b执行需要先获取锁
  3.     public synchronized void a() {
  4.         sleep(1);
  5.         log.debug("1");
  6.     }
  8.     public synchronized void b() {
  9.         log.debug("2");
  10.     }
  12.     // c执行不需要获取锁
  13.     public void c() {
  14.         log.debug("3");
  15.     }
  16. }
  17. public static void main(String[] args) {
  18.     Number n1 = new Number();
  19.     new Thread(()->{ n1.a(); }, "t1").start();
  20.     new Thread(()->{ n1.b(); }, "t2").start();
  21.     new Thread(()->{ n1.c(); }, "t3").start();
  22. }

此时主方法中存在三个线程，c无需获取锁，它会和t1、t2中先获得锁的那个线程同时输出，输出的前后顺序不固定，后续的分析就和上面的一样了。

4. 四锁

  1. class Number{
  2.     public synchronized void a() {
  3.         sleep(1);
  4.         log.debug("1");
  5.     }
  6.     public synchronized void b() {
  7.         log.debug("2");
  8.     }
  9. }
  10. public static void main(String[] args) {
  11.     Number n1 = new Number();
  12.     Number n2 = new Number();
  13.     new Thread(()->{ n1.a(); }, "t1").start();
  14.     new Thread(()->{ n2.b(); }, "t2").start();
  15. }

此时t1和t2两个线程之间不存在锁竞争问题，所以它们可以同时获得各自的锁，但是由于t1需要先睡眠1s，所以先输出为2，等待1s后输出1。

5. 五锁

  1. class Number{
  2.     // 锁对象为Number.Class
  3.     public static synchronized void a() {
  4.         sleep(1);
  5.         log.debug("1");
  6.     }
  8.     // 锁对象为this对象
  9.     public synchronized void b() {
  10.         log.debug("2");
  11.     }
  12. }
  13. public static void main(String[] args) {
  14.     Number n1 = new Number();
  15.     new Thread(()->{ n1.a(); }, "t1").start();
  16.     new Thread(()->{ n2.b(); }, "t2").start();
  17. }

t1和t2两个线程之间仍然不存在线程竞争问题，所以依然先输出为2，等待1s后输出1。

6. 六锁

  1. class Number{
  2.     // 锁对象为Number.Class
  3.     public static synchronized void a() {
  4.         sleep(1);
  5.         log.debug("1");
  6.     }
  8.     // 锁对象为Number.Class
  9.     public static synchronized void b() {
  10.         log.debug("2");
  11.     }
  12. }
  13. public static void main(String[] args) {
  14.     Number n1 = new Number();
  15.     new Thread(()->{ n1.a(); }, "t1").start();
  16.     new Thread(()->{ n2.b(); }, "t2").start();
  17. }

t1和t2线程竞争的都是Number.Class这个对象锁，所以输出情况了一锁相同：

  • 先输出2，等待1s后输出1
  • 等待1s后输出1，然后输出2

7. 七锁

  1. class Number{
  2.      // 锁对象为Number.Class
  3.     public static synchronized void a() {
  4.         sleep(1);
  5.         log.debug("1");
  6.     }
  8.     // 锁对象为this对象
  9.     public synchronized void b() {
  10.         log.debug("2");
  11.     }
  12. }
  13. public static void main(String[] args) {
  14.     Number n1 = new Number();
  15.     Number n2 = new Number();
  16.     new Thread(()->{ n1.a(); }).start();
  17.     new Thread(()->{ n2.b(); }).start();
  18. }

此时t1和t2两个线程之间不存在锁竞争问题，所以它们可以同时获得各自的锁，但是由于t1需要先睡眠1s，所以先输出为2，等待1s后输出1。

8. 八锁

  1. class Number{
  2.     // 锁对象为Number.Class
  3.     public static synchronized void a() {
  4.         sleep(1);
  5.         log.debug("1");
  6.     }
  8.     // 锁对象为Number.Class
  9.     public static synchronized void b() {
  10.         log.debug("2");
  11.     }
  12. }
  13. public static void main(String[] args) {
  14.     Number n1 = new Number();
  15.     Number n2 = new Number();
  16.     new Thread(()->{ n1.a(); }).start();
  17.     new Thread(()->{ n2.b(); }).start();
  18. }

此时，t1和t2线程通过不同的Number对象启动，但是它们竞争的仍然都是Number.Class这个类对象锁，所以输出情况了一锁、六锁相同：

  • 先输出2，等待1s后输出1
  • 等待1s后输出1，然后输出2

看完了线程八锁问题，你应该对于synchronized 对象的锁问题有了清晰的理解与使用了~