【JavaSE】线程的同步和死锁，synchronized对象锁和全局锁，一个生活的例子解释。

1.多线程为什么要加锁？

• 因为在多线程启动之后，所有线程都是无顺序任意运行的，甚至几乎同时访问同一个资源或者代码块，所以上一个线程对资源所做的改变，还没来得及使用，就有可能被下一个线程所覆盖。
• 引入锁的概念，就是为了让竞争资源在各个线程使用的时候可以互不影响。

2.synchronized三种使用方法

对象锁

• 在一个普通类中定义一个synchronized代码块或者方法
• 代码块使用方法

//在方法中使用
synchronized(对象(一般是this)){
    	...
}

• 对象锁的方法

//在普通类中使用
public synchronized void sale(int ticket){
	...
}

• 对象锁只能对同一对象进行加锁操作。
• 不同线程用同一个对象访问对象锁的时候，后来的线程会等待。
• 如果是不同线程拿着不同对象访问对象锁，互不影响

全局锁(类锁)

• 全局锁定义的方法就是给对象锁的方法加一个static关键字。全局代码块的书写方式如下:

synchronized(类名称.class){
    ...
}

• 这时候锁子变成了静态的，不单单只限制某一个对象，可以类比静态变量。它的作用域是这个类的所有对象。
• 所以全局锁无论是否是同一个对象，只要多个线程执行此代码块或者此方法就会互斥进行访问。

任意对象的锁

• 可以创建Object的实例化对象。进行代码块的加锁操作。

	Object obj = new Object();
            synchronized (obj){
               ...
            }

• 这个方法要注意String字符串的加锁，因为字符串有一个常量池，创建相同值的字符串，会引用同一个对象的地址。

需要注意

• 不同线程用同一个对象访问对象锁的时候，线程A先访问西了synchronized的代码块或者方法，只要线程B还没有访问到synchronized的代码块或者调用了其他普通方法，线程B依然可以访问，不受锁的影响。
• 不同线程用同一个对象访问对象锁的时候，如果线程A先访问了synchronized的代码块或者方法，线程B就不可能再去访问别的被锁住的代码块或者方法，因为现在锁的钥匙没在它手里，只有等线程A执行完毕，线程B得到钥匙才可以访问。
• 以上两条适用于全局锁。

class Sync{
    public static synchronized void test(){
        System.out.println("当前线程为"+Thread.currentThread().getName());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程结束"+Thread.currentThread().getName());
    }
    public synchronized static void test1(){  //可以将锁去掉，测测普通方法会不会互斥
        System.out.println("可以执行？");
    }
}

class MyThread implements Runnable{
    private boolean flag;

    public MyThread(boolean flag) {
        this.flag = flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public void run(){
        Sync sync = new Sync();
        if(flag == true) {   //为了让两个线程访问不同的方法
            sync.test();
        }else{
            sync.test1();
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread(true);
        Thread thread1 = new Thread(thread,"线程1");
        Thread thread2 = new Thread(thread,"线程2");
        thread1.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.setFlag(false);
        thread2.start();
    }
}

• 上面的代码就是以全局锁为例，创建两个线程thread1和thread2，先让thread1线程访问被锁的方法，然后让thread2访问被锁的另一个方法。

3.synchronized同步方法底层实现

• 当使用synchronized标记方法时，字节码会出现访问标记ACC_SYNCHRONIZED。该标记表示在进入该方法时，JVM需要进行monitorenter操作。在退出方法时，无论是否正常返回，JVM均需要进行monitorexit操作。
• 当JVM执行moniterenter时，如果目标对象monitor的计数器为0，表示此时该对象没有被其他线程所持有。此时JVM会将该锁对象的持有线程设置为当前线程，并且将monitor计数器+1。

可重入锁概念

• 在目标锁对象的计数器不为0的情况下，如果锁对象的持有线程是当前线程。JVM可将计数器再次+1(可重入锁，比如在加锁方法test1方法里调用同一类中另一个加锁方法test2)；否则需要等待，直到持有线程释放该锁。
• 当执行monitorexit指令时，JVM需要将对象计数器-1。当计数器减为0时，代表该锁已被释放掉，唤醒所有正在等待的线程去竞争该锁。

对象锁机制

• 是JDK1.6之前synchronized底层原理，又称为JDK1.6重量级锁，线程的阻塞以及唤醒均需要操作系统由用户态切换到内核态，开销非常之大，因此效率很低。

4.synchronized锁一个有趣的例子

打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。
这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。
另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。
在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法，否则这个key还有啥意义。当然也就不会有我们的这个主题了。
一个人想进入某间上了锁的房间，他来到房子门口，看见钥匙在那儿（说明暂时还没有其他人要使用上锁的 房间）。于是他走上去拿到了钥匙
，并且按照自己 的计划使用那些房间。注意一点，他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间，
中间他也要把钥匙还回去，再取回来。
因此，普通情况下钥匙的使用原则是：“随用随借，用完即还。”
这时其他人可以不受限制的使用那些不上锁的房间，一个人用一间可以，两个人用一间也可以，没限制。但是如果当某个人想要进入上锁的房
间，他就要跑到大门口去看看了。有钥匙当然拿了就走，没有的话，就只能等了。