首页 » 漏洞 » Java多线程并发编程 Synchronized关键字

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关键字,转载请注明来源!

0