synchronized

1. synchronized的介绍

synchronized属于Java关键字，属于JVM层次，特别说明它不是一个类，也不是一个接口

线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

2. synchronized修饰普通方法

2.1 多个线程一个锁

当多个线程访问MyThread里面的run方法时，以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会产生锁竞争的问题）

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public synchronized void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread, "t1");
        Thread t2 = new Thread(myThread, "t2");
        Thread t3 = new Thread(myThread, "t3");
        Thread t4 = new Thread(myThread, "t4");
        Thread t5 = new Thread(myThread, "t5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

执行上述代码，其输出结果为：

t1 count = 4
t5 count = 3
t4 count = 2
t3 count = 1
t2 count = 0

2.2 多个线程多个锁

多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁，分别获得锁之后，执行synchronized方法体的内容

public class MultiThread {

    private int num = 0;

    /** static */
    public synchronized void printNum(String tag){
        try {
            if(tag.equals("a")){
                num = 100;
                System.out.println("tag a, set num over!");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("tag b, set num over!");
            }

            System.out.println("tag " + tag + ", num = " + num);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //注意观察run方法输出顺序
    public static void main(String[] args) {

        //俩个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                m2.printNum("b");
            }
        });

        t1.start();
        t2.start();
    }
}

执行上述代码，其输出结果为：

tag a, set num over!
tag b, set num over!
tag b, num = 200
tag a, num = 100

关键字synchronized取得的锁都是对象锁，而不是把一段代码(方法)当作锁，所以上述示例代码中那个线程先执行synchronized关键字的方法，那个线程就持有该方法所属对象的锁。两个对象，线程获得的就是两个不同的锁，它们互不影响

3. synchronized修饰静态方法

有一种情况则是相同的锁，即在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）

public class MultiThread {

    private static int num = 0;

    public static synchronized void printNum(String tag){
        try {
            if(tag.equals("a")){
                num = 100;
                System.out.println("tag a, set num over!");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.ou