synchronized 笔记

时间：2019-08-18 23:29:38 阅读：145 评论：0 收藏：0 [点我收藏+]

1. 当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法

对于每一个实例方法，锁是加在对象上的，一个线程访问其中一个 synchronized 修饰的实例方法时，这个线程就拿到了对象的锁，所以其他线程无法拿到该对象的锁，也就无法访问该对象的其他 synchronized 方法

2. synchronized 修饰实例方法，两个（或多个）线程拿到同一个对象的锁，实现正确并发。

一个简单的 +1 线程：

 1 class MyThread implements Runnable {
 2     static int i;
 3 
 4     public int getI() {
 5         return i;
 6     }
 7 
 8     public synchronized void incrI() {
 9         i++;
10     }
11 
12     @Override
13     public void run() {
14         for (int j = 0; j < 1000000; j++) {
15             incrI();
16         }
17     }
18 }

两个线程拿到同一个对象（myThread）的锁：

 1 public class SynTest {
 2     public static void main(String[] args) throws InterruptedException {
 3         MyThread myThread = new MyThread();
 4         Thread t1 = new Thread(myThread);
 5         Thread t2 = new Thread(myThread);
 6         t1.start();
 7         t2.start();
 8         t1.join();
 9         t2.join();
10 
11         System.out.println(MyThread.i);
12     }
13 }

3. 当 synchronized 作用于静态方法时，其锁就是当前类的 class 对象锁。所以可以用两个不同的对象构造两个线程，但是这两个线程拿到的都是同一把锁（class 对象锁），所以仍然可以实现正确的并发。

1 public synchronized static void incrI() {
2     i++;
3 }

 1 public class SynTest {
 2     public static void main(String[] args) throws InterruptedException {
 3         MyThread myThread = new MyThread();
 4         Thread t1 = new Thread(myThread);
 5         Thread t2 = new Thread(new MyThread());
 6         t1.start();
 7         t2.start();
 8         t1.join();
 9         t2.join();
10 
11         System.out.println(MyThread.i);
12     }
13 }

4. synchronid 底层实现

修饰代码块：monitorenter 和 monitorexit 指令。

测试代码：

1 public class SynBlock {
2     private int i;
3 
4     public void incr() {
5         synchronized (this) {
6             i++;
7         }
8     }
9 }