多线程基础篇-08

文章目录

第八章 synchronized

---

---

一、Synchronized关键字的用法

Synchronized可以用于对代码块或方法进行修饰，而不能够用于对class以及变量进行修饰。

1.同步方法

     同步方法的语法非常就简单，即[default|public|private|protected] Synchronized [static] type method().实例代码如下：
     public synchronized void sync(){
     .....
     }
     public synchronized static void staticsync(){
     .....
     }

2.同步代码块

    同步代码快的语法示例如下：
    private final Object MUTEX = new Object();
    public void sync(){
        synchronized (MUTEX){
        ......
        }
    }

介绍了什么是synchronized 关键字以及他的基本用法后，我们再一次改写一下叫号程序：

3.使用synchronize需要注意的问题

在讲解了synchronized 关键字的用法后，以下罗列几个容易出现的错误。
1、与monitor关联的对象不能为空
private final Object mutex = null;
public void syncMethod(){
synchronized(mutex){
…
}
}
mutex为null，很多人还是会犯这么简单的错误，每一个对象和一个monitor关联，对象都为null了，monitor肯定无从谈起。
2、synchronized 作用域太大
由于synchronized 关键字存在排他性，也就是说所有的线程必须串行地经过synchronized 保护的共享区域，如果synchronized 作用域越大，则代表着其效率越低，甚至还会丧失并发的优势，示例代码如下：
public static class Task implements Runnable{
@Override
public synchronized void run(){
…
}
}
上面的代码对整个线程的执行逻辑单元都进行synchronized 同步，从而丧失了并发的能力，synchronized 关键字应该尽可能地作用于共享资源(数据)的读写作用域。
3、不同的monitor企图锁相同的方法
举例说明
public static class Task implements Runnable
{
private final Object MUTEX = new Object();
@Override
public void run(){
synchronized ()
{
…
}
}
}
public static void main(String[] args)
{
for(int i=0;i<5;i++)
{
new Thread(Task::new).start();
}
}
上面的代码构造了5个线程，同时也构造了5个Runnable实例，Runnable作为线程的逻辑执行单元传递给Thread，然后发现，synchronized 根本胡吃不了与之对应的作用域，线程之间进行monitor lock的争抢只能发生在与monitor关联的同一个引用上，上面的代码，每一个线程争抢的monitor关联引用都是彼此独立的，因此不可能起到互斥的作用。
4、多个索的交叉导致死锁
多个锁的交叉很容易引起线程出现死锁的情况，程序并没有任何错诶输出，但就是不工作，如下代码所示：
private final Object MUTEX_READ = new Object();
private final Object MUTEX_WRITE = new Object();
public void read()
{
synchronized (MUTEX_READ )
{
synchronized (MUTEX_WRITE )
{
…
}
}
}

public void write()
{
synchronized (MUTEX_WRITE )
{
synchronized (MUTEX_READ )
{
…
}
}
}

二、This monitor和class Monitor的详细介绍

多个线程争抢同一个monitor的lock会陷入阻塞进而达到数据同步、资源同步的目的，本节介绍两种比较特别的monitor。

1.This monitor

下面的代码ThisLock 中，两个方法m1和m2都被synchronized 关键字修饰，启动两个线程分别访问m1和m2，由于synchronized 关键字修饰了同一个实例对象的两个不同方法，那么只会有一个方法被调用，另一个方法没有被调用。
public class SynchronizedThis {
public static void main(String[] args) {
ThisLock thisLock = new ThisLock();
new Thread(“T1”) {
@Override
public void run() {
thisLock.m1();
}
}.start();
new Thread(“T2”) {
@Override
public void run() {
thisLock.m2();
}
}.start();
}
}

class ThisLock {
public synchronized void m1() {
for (int i = 0; i <= 50; i++) {
System.out.println(Thread.currentThread().getName()+i);
try {
Thread.sleep(2_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public synchronized  void m2() {
    for (int i = 0; i <= 50; i++) {
        System.out.println(Thread.currentThread().getName()+i);
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
可见使用synchronized 关键字同步类的不同实例方法，争抢的是同一个monitor的lock，而与之关联的引用则是ThisLock 的实例引用，为了验证我们的推论，将上面m2的方法稍作修改，如下所示：
public void m2() {
synchronized(this)
{
for (int i = 0; i <= 50; i++) {
System.out.println(Thread.currentThread().getName()+i);
try {
Thread.sleep(2_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
其中m1保持方法同步的方式，m2则采用同步代码块的方式，并且使用的是this的monitor，运行修改后的代码会发现效果完全一样。

2.Class monitor

同样的方式，来看下面的例子，有两个静态方法分别使用synchronized 对其进行同步
public class SynchronizedStaticTest {
public static void main(String[] args) {
new Thread(“T1”) {
@Override
public void run() {
SynchronizedStatic.m1();
}
}.start();

    new Thread("T2") {
        @Override
        public void run() {
            SynchronizedStatic.m2();
        }
    }.start();    
}

}

public class SynchronizedStatic {
public synchronized static void m1() {
System.out.println("m1 " + Thread.currentThread().getName());
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public synchronized static void m2() {
    System.out.println("m2 " + Thread.currentThread().getName());
    try {
        Thread.sleep(10_000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

}
运行上面的例子，在同一时刻只能有一个线程访问SynchronizedStatic 的静态方法，我们可以得出用synchronized 同步某个类的不同静态方法争抢的也是同一个monitor的lock。与该monitor关联的引用是SynchronizedStatic .class实例。
对上面代码稍作修改，然后运行会发现具有同样的效果，实例代码如下：
public static void m2()
{
synchronized (SynchronizedStatic .class)
{
System.out.println("m2 " + Thread.currentThread().getName());
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
其中静态方法m1继续保持同步方法的方式，而m2则修改为同步代码快的方式，使用SynchronizedStatic .class的实例引用作为monitor。