Java并发学习之synchronized使用小结

时间 2019-11-11

标签 java 并发学习 synchronized 使用小结栏目 Java 繁體版

原文原文链接

`synchronized`工做原理及使用小结

为确保共享变量不会出现并发问题，一般会对修改共享变量的代码块用synchronized加锁，确保同一时刻只有一个线程在修改共享变量，从而避免并发问题java

本篇将集中在synchronized关键字的工组原理以及使用方式上安全

I. 工做原理

以一个case进行分析，源码以下多线程

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {
            System.out.println("Method 1 start");
        }
    }
}

在加锁的代码块，多了一个 monitorenter , monitorexit并发

每一个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的全部权，过程以下：性能

若是monitor的进入数为0，则该线程进入monitor，而后将进入数设置为1，该线程即为monitor的全部者。
若是线程已经占有该monitor，只是从新进入，则进入monitor的进入数加1.
若是其余线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再从新尝试获取monitor的全部权

执行monitorexit的线程必须是objectref所对应的monitor的全部者。测试

指令执行时，monitor的进入数减1
若是减1后进入数为0，那线程退出monitor，再也不是这个monitor的全部者
其余被这个monitor阻塞的线程能够尝试去获取这个 monitor 的全部权

锁this

谈到 synchronized 就不可避免的要说到锁这个东西，基本上在网上能够搜索到一大批的关于偏向锁，轻量锁，重量锁的讲解文档，对这个东西基本上我也不太理解，多看几篇博文以后，简单的记录一下操作系统

先抛一个结论： 轻量级锁是为了在线程交替执行同步块时提升性能，而偏向锁则是在只有一个线程执行同步块时进一步提升性能线程

1. 偏向锁

获取过程code

判断是否为可偏向状态
是，则判断线程ID是否指向当前线程
- 是，即表示这个偏向锁就是这个线程持有，直接执行代码块
- 否，经过CAS操做竞争锁
  - 竞争成功，则设置线程ID为当前线程，并执行代码块；
  - 竞争失败，说明多线程竞争啦，问题严重了，当偏向锁到达安全点时，将偏向锁升级为轻量锁

释放过程

当偏向锁遇到其余线程尝试竞争时，持有偏向锁的线程会释放，并升级为轻量锁
到达安全点，暂停拥有偏向锁的线程，判断锁对象是否处于被锁的状态，撤销偏向锁后恢复到未锁定（标志位为“01”）或轻量级锁（标志位为“00”）的状态。

2. 轻量锁

“轻量级”是相对于使用操做系统互斥量来实现的传统锁而言的。

可是，首先须要强调一点的是，轻量级锁并非用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减小传统的重量级锁使用产生的性能消耗。

在解释轻量级锁的执行过程以前，先明白一点，轻量级锁所适应的场景是线程交替执行同步块的状况，若是存在同一时间访问同一锁的状况，就会致使轻量级锁膨胀为重量级锁

3. 转换

简单来说，单线程时，使用偏向锁，若是这个时候，又来了一个线程访问这个代码块，那么就要升级为轻量锁，若是这个线程在访问代码块同时，又来了一个线程来访问这个代码块，那么就要升级为重量锁了。下面更多的显示了这些变更时，标记位的随之改变

II. 三中使用姿式

1. 三种方法说明

修饰实例方法

多个线程访问同一个实例的加锁方法时，会出现锁的竞争
修饰静态方法

多个线程访问类的加锁方法时，会出现锁的竞争
修饰代码块

多线程访问到同一个代码块时，会出现竞争的问题

2. 几个疑问

一个case： TestDemo方法定义以下

public class TestDemo {
  public synchronized void a() { 
    // ...
  }
  public synchronized void b() { 
    // ...
  }
  public static synchronized void c() { 
    // ...
  }
  public static synchronized void d() { 
    // ...
  }
  public void e() {
  // ...
  }
  
  public void f() {
    synchronized(this) {
    // ....
    }
  }
  
  public void g() {
    synchronized(this) {
    // ....
    }
  }
}

线程1访问a方法时，线程2访问a方法会被阻塞；若此时线程2访问b方法会被阻塞么？访问c，d, e方法呢？
线程1访问c方法时，线程2访问c方法会被阻塞，若此时线程2访问d方法会被阻塞么，访问a,b,e方法呢？
线程1进入f方法内部的同步代码块，此时线程2若访问f会被阻塞；那么线程2访问g方法会如何？访问a,b,c,d,e方法又是怎样？

对上面的问题，核心的一点就是synchronized是否只做用于修饰的代码块or方法上

3. 测试验证

TestDemo的具体实现以下

public class TestDemo {

    public synchronized void a(String msg) {
        System.out.println(Thread.currentThread().getName() + ":a() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":a() after: " + msg);
    }


    public synchronized void b(String msg) {
        System.out.println(Thread.currentThread().getName() + ":b() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":b() after: " + msg);
    }

    public static synchronized void c(String msg) {
        System.out.println(Thread.currentThread().getName() + ":c() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":c() after: " + msg);
    }


    public static synchronized void d(String msg) {
        System.out.println(Thread.currentThread().getName() + ":d() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":d() after: " + msg);
    }


    public void e(String msg) {
        System.out.println(Thread.currentThread().getName() + ":e() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":e() after: " + msg);
    }


    public void f(String msg) {
        System.out.println(Thread.currentThread().getName() + ":f() before");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":f() after: " + msg);
    }


    public void g(String msg) {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + ":a() before");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":a() after: " + msg);
        }
    }


    public void h(String msg) {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + ":h() before");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":h() after: " + msg);
        }
    }
}

测试一 实例加锁方法的访问测试

/**
 * 非静态同步方法测试
 */
private void nonStaticSynFun() throws InterruptedException {

    TestDemo testDemo = new TestDemo();

    Thread thread1 = new Thread(()->testDemo.a("访问同一加锁方法"), "thread1");
    Thread thread2 = new Thread(()->testDemo.a("访问同一加锁方法"), "thread2");

    System.out.println("---两个线程，访问同一个加锁方法开始---");
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();
    System.out.println("---两个线程，访问同一个加锁方法结束---\n");

  
    // 

    TestDemo testDemo2 = new TestDemo();
    thread1 = new Thread(()->testDemo.a("访问第一个实例同一加锁方法"), "thread1");
    thread2 = new Thread(()->testDemo2.a("访问第二个实例同一加锁方法"), "thread2");

    System.out.println("---两个线程，访问两个实例同一个加锁方法开始---");
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();
    System.out.println("---两个线程，访问两个同一个加锁方法结束---\n");

    //

    thread1 = new Thread(()->testDemo.a("访问两个加锁方法"), "thread1");
    thread2 = new Thread(()->testDemo.b("访问两个加锁方法"), "thread2");
    System.out.println("---两个线程，访问两个加锁方法开始---");
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();
    System.out.println("---两个线程，访问两个加锁方法结束---\n");


    //
    thread1 = new Thread(()->testDemo.a("访问加锁实例方法"), "thread1");
    thread2 = new Thread(()->TestDemo.c("访问加锁静态方法"), "thread2");
    System.out.println("---两个线程，访问实例和静态加锁方法开始---");
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();
    System.out.println("---两个线程，访问实例和静态加锁方法结束---\n");

}

@Test
public void testNoStaticSynFun() throws InterruptedException {
    for(int i = 0; i < 2000; i++) {
        nonStaticSynFun();
    }
}

上面的测试case主要覆盖：

两个线程访问一个实例的同一个加锁方法（指望阻塞，顺序执行）
线程1访问实例1的加锁方法，线程2访问实例2的加锁方法（无阻塞，并发执行）
两个线程访问一个实例的两个加锁方法
两个线程，一个访问实例的加锁方法，一个访问静态加锁方法

输出结果以下

---两个线程，访问同一个加锁方法开始---
thread1:a() before
thread1:a() after: 访问同一加锁方法
thread2:a() before
thread2:a() after: 访问同一加锁方法
---两个线程，访问同一个加锁方法结束---

---两个线程，访问两个实例同一个加锁方法开始---
thread1:a() before
thread2:a() before
thread2:a() after: 访问第二个实例同一加锁方法
thread1:a() after: 访问第一个实例同一加锁方法
---两个线程，访问两个同一个加锁方法结束---

---两个线程，访问两个加锁方法开始---
thread1:a() before
thread1:a() after: 访问两个加锁方法
thread2:b() before
thread2:b() after: 访问两个加锁方法
---两个线程，访问两个加锁方法结束---

---两个线程，访问实例和静态加锁方法开始---
thread1:a() before
thread2:c() before
thread2:c() after: 访问加锁静态方法
thread1:a() after: 访问加锁实例方法
---两个线程，访问实例和静态加锁方法结束---

验证结果：

同一个实例中加锁的方法，只要有一个线程已经获取到了锁，其余线程再去访问时，都会被阻塞（即此时的锁，是一个实例共享同一把锁；不一样的实例，锁不一样）
一个线程获取到一个实例中的加锁方法的锁时，另外一个线程依然能够访问静态加锁方法（即实例的锁与静态方法的锁是不一样的，二者不影响）

测试case二： 静态加锁方法测试

private void staticSynFun() throws InterruptedException {
    Thread thread1 = new Thread(() -> TestDemo.c("访问加锁静态方法"), "thread1");
    Thread thread2 = new Thread(() -> TestDemo.c("访问加锁静态方法"), "thread2");

    System.out.println("---两个线程，访问静态加锁方法开始---");
    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();
    System.out.println("---两个线程，访问静态加锁方法结束---\n");


    //

    TestDemo testDemo1 = new TestDemo(), testDemo2 = new TestDemo();
    thread1 = new Thread(() -> testDemo1.c("访问加锁静态方法"), "thread1");
    thread2 = new Thread(() -> testDemo2.d("访问加锁静态方法"), "thread2");
    Thread thread3 = new Thread(() -> testDemo1.a("访问加锁实例方法"), "thread3");

    System.out.println("---两个线程，访问不一样实例的静态加锁方法开始---");
    thread1.start();
    thread2.start();
    thread3.start();

    thread1.join();
    thread2.join();
    thread3.join();
    System.out.println("---两个线程，访问不一样实例的静态加锁方法结束---\n");
}

@Test
public void testStaticSynFunc() throws InterruptedException {
    for (int i = 0; i < 2000; i++) {
        staticSynFun();
    }
}

上面的测试主要覆盖

两个线程访问相同的静态加锁方法（期待阻塞）
三个线程，两个访问不一样实例的静态加锁方法，一个访问实例加锁方法