Java 中的 synchronized 同步锁

        导致线程安全问题的根本原因在于，存在多个线程同时操作一个共享资源，要想解决这个问题，就需要保证对共享资源访问的独占性，因此人们在Java中提供了synchronized关键字，我们称之为同步锁，它可以保证在同一时刻，只允许一个线程执行某个方法或代码块。
        synchronized同步锁具有互斥性，这相当于线程由并行执行变成串行执行，保证了线程的安全性，但是损失了性能。下面我们先来看一下synchronized的使用方法。

synchronized 的使用方法

synchronized 的使用方法比较简单，修饰方式有如下两种。

• 作用在方法级别，表示针对m1()方法加锁，当多个线程同时访问m1()方法时，同一时刻只有一个线程能执行。

public synchronized void m1(){
    //省略代码
}

作用在代码块级别，表示针对某一段线程不安全的代码加锁，只有访问到synchronized(this)这行代码时，才会去竞争锁资源。
 

public void m2( ){ 
    synchronized(this){
        //省略代码
    }
}

        了解了 synchronized的基本使用语法之后，我们来看如图所示的流程，它针对上面的案例增加了 synchronized 同步锁之后的执行流程。简单地说，当多个线程同时访问加synchronized关键字修饰的方法时，需要先抢占一个锁标记，只有抢到锁标记的线程才有资格调用incr()方法。这就使得在同一时刻只有一个线程执行i++操作，从而解决了原子性问题。

了解 synchronized 同步锁的作用范围

        我们对一个方法增加synchronized关键字后，当多个线程访问该方法时，整个执行过程会变成串行执行，这种执行方式很明显会影响程序的性能，那么如何做好安全性及性能的平衡呢?
        实际上，synchronized关键字只需要保护可能存在线程安全问题的代码，因此，我们可以通过控制同步锁的作用范围来实现这个平衡机制。在synchronized 中，提供了两种锁，一是类锁，二是对象锁。
        类锁
        类锁是全局锁，当多个线程调用不同对象实例的同步方法时会产生互斥,具体实现方式如下。  

• 修饰静态方法:

public static synchronized void m1( ){
    //省略代码
}

• 修饰代码块，synchronized 中的锁对象是类，也就是Lock.class。

public class Lock{ 
    public void m2(){
        synchronized(Lock.class){
            //省略代码
        }
    }
}

        下面这段程序使用类锁来实现跨对象实例，从而实现互斥的功能。

public class SynchronizedExample{

    public void m1( ) {
        synchronized(SynchronizedExample.class) {
            while (true){
                System.out.println("当前访问的线程:"+Thread.currentThread( ).getName());                         
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args){
        SynchronizedExample se1=new SynchronizedExample(); 
        SynchronizedExample se2=new SynchronizedExample(); 
        new Thread(()->se1.m1(),"t1").start(); 
        new Thread(()->se2.m1(),"t2" ).start();
    }
}

• 该程序中定义了一个m1()方法，该方法中实现了一个循环打印当前线程名称的逻辑，并且这段逻辑是用类锁来保护的。
• 在 main()方法中定义了两个SynchronizedExample对象实例sel和se2，又分别定义了两个线程来调用这两个实例的m10方法。

        根据类锁的作用范围可以知道，即便是多个对象实例，也能够达到互斥的目的，因此最终输出的结果是：哪个线程抢到了锁，哪个线程就持续打印自己的线程名称。

        对象锁
        对象锁是实例锁，当多个线程调用同一个对象实例的同步方法时会产生互斥，具体实现方式如下。

• 修饰普通方法:

public synchronized void m1( ){
    //省略代码
}

• 修饰代码块，synchronized中的锁对象是普通对象实例。

public class Lock{
    Object lock=new 0bject( ); public void m2( ){
        synchronized(lock){
            //省略代码
        }
    }
}

        下面这段程序演示了对象锁的使用方法，代码如下。

public class SynchronizedForobjectExample {
    Object lock=new 0bject(); 
    public void m1( ){
        synchronized (lock){
            while(true){
                System.out.println("当前获得锁的线程:"+Thread.currentThread().getName());
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();}
                }
        }
    }

    public static void main(String[] args) {
        SynchronizedFor0bjectExample se1=new SynchronizedForobjectExample();             
        SynchronizedForObjectExample se2=new SynchronizedForobjectExample(); 
        new Thread(()->se1.m1(),"t1").start(); 
        new Thread(()->se2.m1(),"t2" ).start();
    }
}

我们先来看一下打印结果。

当前获得锁的线程:t1

当前获得锁的线程:t2

当前获得锁的线程:t2

当前获得锁的线程:t1

当前获得锁的线程:t1

当前获得锁的线程:t2

当前获得锁的线程:t1

当前获得锁的线程:t2

        从以上结果中我们发现，对于几乎相同的代码，在使用对象锁的情况下，当两个线程分别访问两个不同对象实例的m10方法时，并没有达到两者互斥的目的，看起来似乎锁没有生效，实际上并不是锁没有生效，问题的根源在于synchronized(lock)中锁对象lock的作用范围过小。
        Class是在JVM启动过程中加载的，每个.class文件被装载后会产生一个Class对象，Class对象在JVM进程中是全局唯一的。通过static修饰的成员对象及方法的生命周期都属于类级别，它们会随着类的定义被分配和装载到内存，随着类被卸载而回收。
        实例对象的生命周期伴随着实例对象的创建而开始，同时伴随着实例对象的回收而结束。

        因此，类锁和对象锁最大的区别是锁对象lock的生命周期不同，如果要达到多个线程互斥，那么多个线程必须要竞争同一个对象锁。
        在上述代码中，通过Objectlock-new Object();构建的锁对象的生命周期是由Synchronized- ForObjectExample 对象的实例来决定的，不同的SynchronizedForObjectExample 实例会有不同的 lock锁对象，由于没有形成竞争，所以不会实现互斥的效果。如果想要让上述程序达到同步的目的，那么我们可以对lock锁对象增加.static关键字。

static Object lock=new 0bject();

最后，留下一个问题去思考，关于 synchronized 同步锁的思考？同步锁的核心特性是排他，要达到这个目的，多线程必须抢占同一个资源。。。。。。