synchronized实现与运用

前言

最近在看并发编程艺术这本书，对看书的一些笔记及个人工作中的总结。

rewrwe.jpeg

在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是在jdk1.6各种优化之后，有些情况它并不那么重了。
synchronized可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"

对象锁

/**
 * 对象锁
 */
public class SynchronizedTest1 extends Thread {

    private int count = 5;

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

    public static void main(String[] args) {

        SynchronizedTest1 myThread = new SynchronizedTest1();
        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

总结：
当多个线程访问SynchronizedTest1的run方法时，以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码：首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容，拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）。
弊处：就是导致cpu的使用频率过高，更严重的情况导致宕机，我们应该在开发中避免多个线程抢一把锁的问题。

多个线程多个锁

public class SynchronizedTest2 {
    private int num = 0;

    public synchronized void printNum(String tag) {
        try {

            if (tag.equals("a")) {
                num = 100;
                System.out.println("tag a, set num over!");
                Thread.sleep(2000);
            } 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) {

        //俩个不同的对象,所以执行printNum方法的时候就是二把锁，一个对象一把锁，所以二者互相不影响
        final SynchronizedTest2 test1 = new SynchronizedTest2();
        final SynchronizedTest2 test2 = new SynchronizedTest2();

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

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

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

结果：

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

总结：
俩个不同的对象,所以执行printNum方法的时候就是二把锁，一个对象一把锁，所以二者互相不影响。

类级锁
synchronized修饰静态方法

public class SynchronizedTest3 {
    private static int num = 0;

    //synchronized修饰静态关键字
    public static synchronized void printNum(String tag) {
        try {

            if (tag.equals("a")) {
                num = 100;
                System.out.println("tag a, set num over!");
                Thread.sleep(2500);
            } 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 SynchronizedTest3 m1 = new SynchronizedTest3();
        final SynchronizedTest3 m2 = new SynchronizedTest3();

        Thread t1 = new Thread(() -> m1.printNum("a"));

        Thread t2 = new Thread(() -> m2.printNum("b"));

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

    }
}

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

结果：
synchronized修饰的静态方法的锁，表示锁定.class类，类一级别的锁（独占.class类）。
实际工作中为了降低锁的力度，synchronized修饰代码块，从而达到更好的性能。锁是synchronized括号里配置的对象。
同步代码块

//使用synchronized修饰代码块，
public class SynchronizedTest4 {

    private Object obj = new Object();

    public void test() throws Exception{
        System.out.println(Thread.currentThread().getName()+":1111");
        Thread.sleep(10000);
        synchronized (obj){
            System.out.println(Thread.currentThread().getName()+":22222");
        }
        System.out.println(Thread.currentThread().getName()+":33333");
    }

    public static void main(String[] args) {
        final SynchronizedTest4 test4 = new SynchronizedTest4();
        new Thread(() -> {
            try {
                test4.test();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(() -> {
            try {
                test4.test();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();
    }

}

结果：

t1:1111
t2:1111
t1:22222
t2:22222
t2:33333
t1:33333

总结：
java中的每一个对象都可以作为锁：

• 对于普通同步方法，锁的是当前实列对象。
• 对于静态同步方法，锁的是当前类的Class对象。
• 对于同步方法块，锁是Synchonized括号里配置的对象。

当一个线程试图访问同步代码块时，它首先必须要得到锁，退出或抛出异常时必须释放锁。

从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter（监视器锁）和monitorexit指令实现的，而方法同步是使用另外一种方式实现的，同步方法中依靠方法修饰符上的 ACC_SYNCHRONIZED 实现。细节在JVM规范里并没有详细说明。但是，方法的同步同样可以使用这两个指令来实现。

monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。