多线程之互斥锁（synchronized关键字）

synchronized关键字经常被用来做线程互斥锁，但是使用不当的话，经常达不到目的。初学者常对锁住的是对象还是类有疑问。
原理：无论是对象还是类都有唯一的锁，synchronized只是声明了函数调用时需要什么锁，每个锁同一时间只能由一个线程获取，借此实现了线程互斥。
（1）分析对象锁
A.synchronized修饰非静态函数
接下来看实例：

public enum Person {
    Alice,
    Bob;

    public synchronized void say() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " say hello world! " +TimeUtil.getCurrentTime());
    }

    public synchronized void speak() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
    }

    public void print() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " print hello world! " + TimeUtil.getCurrentTime());
    }

}

这是一个Person类，其中有三个函数，say()和speak()这种声明方式意味着调用该函数需要持有Person实例的对象锁，即用哪个实例调用，则需要持有哪个对象的锁。print()函数无需任何锁。

public class ThreadA implements Runnable {
    @Override
    public void run() {
        Person.Alice.say();
    }
}

public class ThreadB implements Runnable {
    @Override
    public void run() {
        Person.Bob.say();
    }
}

public class ThreadC implements Runnable {
    @Override
    public void run() {
        Person.Alice.print();
    }
}

public static String getCurrentTime() {
    SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");
    return sdf.format(new Date());
}

创建多个线程，然后执行函数：

public class Main {
    public static void main(String[] args) {
        Thread threadA = new Thread(new ThreadA());
        threadA.setName("threadA");
        Thread threadB = new Thread(new ThreadB());
        threadB.setName("threadB");
        Thread threadC = new Thread(new ThreadC());
        threadC.setName("threadC");
        threadA.start();
        System.out.println("A启动了 " + TimeUtil.getCurrentTime());
        threadB.start();
        System.out.println("B启动了 " + TimeUtil.getCurrentTime());
        threadC.start();
        System.out.println("C启动了 " + TimeUtil.getCurrentTime());
    }
}

输出结果为：
A启动了 20:26
B启动了 20:26
C启动了 20:26
threadA say hello world! 20:28
threadC print hello world! 24:21
threadB say hello world! 20:28

可以看出，用两个实例分别调用say()函数是不会出现互斥的。函数执行时，每个函数都可以拿到调用对象的锁。
接下来我们进行改动，将ThreadB改为：

public class ThreadB implements Runnable {
    @Override
    public void run() {
        Person.Alice.say();
    }
}

执行输出：
A启动了 25:33
B启动了 25:33
C启动了 25:33
threadA say hello world! 25:35
threadC print hello world! 25:35
threadB say hello world! 25:37
可以明显看出线程B和A存在对象锁竞争，A持有Alice锁的时候，B等待。
改动ThreadB为

public class ThreadB implements Runnable {
    @Override
    public void run() {
        Person.Alice.speak();
    }
}

执行输出：
A启动了 27:29
B启动了 27:29
C启动了 27:29
threadA say hello world! 27:31
threadC print hello world! 27:31
threadB speak hello world! 27:33
可以看出即使用Alice调用不同的函数，还是会出现等待.
总结：对象锁同一时间只能由一个线程持有，此时其余线程无法再用此对象调用需要此对象锁的函数。
B.synchronized修饰代码块
实例如下：

public enum Person {
    Alice,
    Bob;

    public synchronized void say() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " say hello world! " + TimeUtil.getCurrentTime());
    }

    public void speak() {
        synchronized (Alice) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
        }
    }
}

public class ThreadA implements Runnable {
    @Override
    public void run() {
        Person.Alice.say();
    }
}

public class ThreadB implements Runnable {
    @Override
    public void run() {
        Person.Alice.speak();
    }
}

public class Main {
    public static void main(String[] args) {
        Thread threadA = new Thread(new ThreadA());
        threadA.setName("threadA");
        Thread threadB = new Thread(new ThreadB());
        threadB.setName("threadB");
        threadA.start();
        System.out.println("A启动了 " + TimeUtil.getCurrentTime());
        threadB.start();
        System.out.println("B启动了 " + TimeUtil.getCurrentTime());
    }
}

执行输出：
A启动了 35:26
B启动了 35:26
threadA say hello world! 35:28
threadB speak hello world! 35:30
可以看出A和B出现了互斥，A调用的say()函数用
synchronized关键字修饰，所以此时A占用Alice锁，speak中的代码块用synchronized (Alice)修饰，说明同样需要Alice锁，因此互斥。
改动speak函数：

public void speak() {
    synchronized (Bob) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
    }
}

将需求锁改为Bob，执行输出：
A启动了 38:36
B启动了 38:36
threadA say hello world! 38:38
threadB speak hello world! 38:38
可以看到互斥消失了。
继续更改：

    public void speak() {
        synchronized (this) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
        }
    }

这里的this指的是需要调用当前函数的对象锁，执行输出：
A启动了 40:45
B启动了 40:45
threadA say hello world! 40:47
threadB speak hello world! 40:49
互斥又出现了，因为又在竞争Alice锁
（2）分析类锁
每一个类都有唯一且同一时间只能被唯一线程持有的类锁。
实例如下：

public enum Person {
    Alice,
    Bob;

    public static synchronized void say() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " say hello world! " + TimeUtil.getCurrentTime());
    }

    public static synchronized void speak() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
    }
}

public class ThreadA implements Runnable {
    @Override
    public void run() {
        Person.say();
    }
}

public class ThreadB implements Runnable {
    @Override
    public void run() {
        Person.speak();
    }
}

public class Main {
    public static void main(String[] args) {
        Thread threadA = new Thread(new ThreadA());
        threadA.setName("threadA");
        Thread threadB = new Thread(new ThreadB());
        threadB.setName("threadB");
        threadA.start();
        System.out.println("A启动了 " + TimeUtil.getCurrentTime());
        threadB.start();
        System.out.println("B启动了 " + TimeUtil.getCurrentTime());
    }
}

执行输出：
A启动了 44:18
B启动了 44:18
threadA say hello world! 44:20
threadB speak hello world! 44:22
明显看到线程互斥。
改动代码：

    public static void speak() {
        synchronized (Person.class) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " speak hello world! " + TimeUtil.getCurrentTime());
        }
    }

改动speak函数，将里面的的代码用 synchronized (Person.class) 修饰，执行输出：
A启动了 44:18
B启动了 44:18
threadA say hello world! 44:20
threadB speak hello world! 44:22
两个线程依旧互斥，因为还在竞争类锁。

总结：类锁类似对象锁，唯一且同一时间只能由唯一线程持有。

最后补充一点：类锁和对象锁是两套互斥机制，互不影响，具体看你的函数需求的是对象锁（哪个对象）还是类锁