【Java并发编程实战】-----synchronized

在咱们的实际应用当中可能常常会遇到这样一个场景：多个线程读或者、写相同的数据，访问相同的文件等等。对于这种状况若是咱们不加以控制，是很是容易致使错误的。在java中，为了解决这个问题，引入临界区概念。所谓临界区是指一个访问共用资源的程序片断，而这些共用资源又没法同时被多个线程访问。

在java中为了实现临界区提供了同步机制。当一个线程试图访问一个临界区时，他将使用一种同步机制来查看是否是已经有其余线程进入临界区。若是没有则他就能够进入临界区，不然他就会被同步机制挂起，指定进入的线程离开这个临界区。

临界区规定：每次只准许一个进程进入临界区，进入后不容许其余进程进入。调度法则为（百度百科）：

一、若是有若干进程要求进入空闲的临界区，一次仅容许一个进程进入。

二、任什么时候候，处于临界区内的进程不可多于一个。如已有进程进入本身的临界区，则其它全部试图进入临界区的进程必须等待。

三、进入临界区的进程要在有限时间内退出，以便其它进程能及时进入本身的临界区。

四、若是进程不能进入本身的临界区，则应让出CPU，避免进程出现“忙等”现象。

下面介绍使用synchronized关键字来实现同步机制。

1、synchronized关键字

1.一、简介

synchronized，咱们谓之锁，主要用来给方法、代码块加锁。当某个方法或者代码块使用synchronized时，那么在同一时刻至多仅有有一个线程在执行该段代码。当有多个线程访问同一对象的加锁方法/代码块时，同一时间只有一个线程在执行，其他线程必需要等待当前线程执行完以后才能执行该代码段。可是，其他线程是能够访问该对象中的非加锁代码块的。

synchronized主要包括两种方法：synchronized 方法、synchronized 块。

1.二、synchronized 方法

经过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：

public synchronized void getResult();

synchronized方法控制对类成员变量的访问。它是如何来避免类成员变量的访问控制呢？咱们知道方法使用了synchronized关键字代表该方法已加锁，在任一线程在访问改方法时都必需要判断该方法是否有其余线程在“独占”。每一个类实例对应一个把锁，每一个synchronized方法都必须调用该方法的类实例的锁方能执行，不然所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，被阻塞的线程方能得到该锁。

其实synchronized方法是存在缺陷的，若是咱们将一个很大的方法声明为synchronized将会大大影响效率的。若是多个线程在访问一个synchronized方法，那么同一时刻只有一个线程在执行该方法，而其余线程都必须等待，可是若是该方法没有使用synchronized，则全部线程能够在同一时刻执行它，减小了执行的总时间。因此若是咱们知道一个方法不会被多个线程执行到或者说不存在资源共享的问题，则不须要使用synchronized关键字。可是若是必定要使用synchronized关键字，那么咱们能够synchronized代码块来替换synchronized方法。

1.三、synchronized 块

synchronized代码块所起到的做用和synchronized方法同样，只不过它使临界区变的尽量短了，换句话说：它只把须要的共享数据保护起来，其他的长代码块留出此操做。语法以下：

synchronized(object) {  
    //容许访问控制的代码  
}

若是咱们须要以这种方式来使用synchronized关键字,那么必需要经过一个对象引用来做为参数,一般这个参数咱们常使用为this.

synchronized (this) {
    //容许访问控制的代码 
}

对于synchronized(this)有以下理解：

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程获得执行。另外一个线程必须等待当前线程执行完这个代码块之后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另外一个线程仍然能够访问object中的非synchronized(this)同步代码块。

三、尤为关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其余线程对object中全部其余synchronized(this)同步代码块得访问将被阻塞。

四、第三个例子一样适用其余同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就得到了这个object的对象锁。结果，其余线程对该object对象全部同步代码部分的访问都将被暂时阻塞。

五、以上规则对其余对象锁一样适用

http://freewxy.iteye.com/blog/978159，这篇博客使用实例对上面四点进行了较为详细的说明，这里就很少阐述了。

http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html这篇博客对synchronized的使用举了一个很不错的例子（拿钥匙进房间）。这里因为篇幅问题LZ就很少阐述了，下面咱们来刨刨synchronized稍微高级点的东西。

1.四、进阶

在java多线程中存在一个“先来后到”的原则，也就是说谁先抢到钥匙，谁先用。咱们知道为避免资源竞争产生问题，java使用同步机制来避免，而同步机制是使用锁概念来控制的。那么在Java程序当中，锁是如何体现的呢？这里咱们须要弄清楚两个概念：

什么是锁？

什么是锁？在平常生活中，它就是一个加在门、箱子、抽屉等物体上的封缄器，防止别人偷窥或者偷盗，起到一个保护的做用。在java中一样如此，锁对对象起到一个保护的做用，一个线程若是独占了某个资源，那么其余的线程别想用，想用？等我用完再说吧！

在java程序运行环境中，JVM须要对两类线程共享的数据进行协调：

一、保存在堆中的实例变量

二、保存在方法区中的类变量。

在java虚拟机中，每一个对象和类在逻辑上都是和一个监视器相关联的。对于对象来讲，相关联的监视器保护对象的实例变量。 对于类来讲，监视器保护类的类变量。若是一个对象没有实例变量，或者说一个类没有变量，相关联的监视器就什么也不监视。

为了实现监视器的排他性监视能力，java虚拟机为每个对象和类都关联一个锁。表明任什么时候候只容许一个线程拥有的特权。线程访问实例变量或者类变量不需锁。 若是某个线程获取了锁，那么在它释放该锁以前其余线程是不可能获取一样锁的。一个线程能够屡次对同一个对象上锁。对于每个对象，java虚拟机维护一个加锁计数器，线程每得到一次该对象，计数器就加1，每释放一次，计数器就减 1，当计数器值为0时，锁就被彻底释放了。
java编程人员不须要本身动手加锁，对象锁是java虚拟机内部使用的。在java程序中，只须要使用synchronized块或者synchronized方法就能够标志一个监视区域。当每次进入一个监视区域时，java 虚拟机都会自动锁上对象或者类。（摘自java的锁机制）。

锁的是什么？

在这个问题以前咱们必需要明确一点：不管synchronized关键字加在方法上仍是对象上，它取得的锁都是对象。在java中每个对象均可以做为锁，它主要体如今下面三个方面：

对于同步方法，锁是当前实例对象。

对于同步方法块，锁是Synchonized括号里配置的对象。

对于静态同步方法，锁是当前对象的Class对象。

首先咱们先看下面例子：

public class ThreadTest_01 implements Runnable{

    @Override
    public synchronized void run() {
        for(int i = 0 ; i < 3 ; i++){
            System.out.println(Thread.currentThread().getName() + "run......");
        }
    }
    
    public static void main(String[] args) {
        for(int i = 0 ; i < 5 ; i++){
            new Thread(new ThreadTest_01(),"Thread_" + i).start();
        }
    }
}

部分运行结果：

Thread_2run......
Thread_2run......
Thread_4run......
Thread_4run......
Thread_3run......
Thread_3run......
Thread_3run......
Thread_2run......
Thread_4run......

这个结果与咱们预期的结果有点不一样（这些线程在这里乱跑），照理来讲，run方法加上synchronized关键字后，会产生同步效果，这些线程应该是一个接着一个执行run方法的。在上面LZ提到，一个成员方法加上synchronized关键字后，实际上就是给这个成员方法加上锁，具体点就是以这个成员方法所在的对象自己做为对象锁。可是在这个实例当中咱们一共new了10个ThreadTest对象，那个每一个线程都会持有本身线程对象的对象锁，这一定不能产生同步的效果。因此：若是要对这些线程进行同步，那么这些线程所持有的对象锁应当是共享且惟一的！

这个时候synchronized锁住的是那个对象？它锁住的就是调用这个同步方法对象。就是说threadTest这个对象在不一样线程中执行同步方法，就会造成互斥。达到同步的效果。因此将上面的new Thread(new ThreadTest_01(),"Thread_" + i).start(); 修改成new Thread(threadTest,"Thread_" + i).start();就能够了。

对于同步方法，锁是当前实例对象。

上面实例是使用synchronized方法，咱们在看看synchronized代码块：

public class ThreadTest_02 extends Thread{

    private String lock ;
    private String name;
    
    public ThreadTest_02(String name,String lock){
        this.name = name;
        this.lock = lock;
    }
    
    @Override
    public void run() {
        synchronized (lock) {
            for(int i = 0 ; i < 3 ; i++){
                System.out.println(name + " run......");
            }
        }
    }
    
    public static void main(String[] args) {
        String lock  = new String("test");
        for(int i = 0 ; i < 5 ; i++){
            new ThreadTest_02("ThreadTest_" + i,lock).start();
        }
    }
}

运行结果：

ThreadTest_0 run......
ThreadTest_0 run......
ThreadTest_0 run......
ThreadTest_1 run......
ThreadTest_1 run......
ThreadTest_1 run......
ThreadTest_4 run......
ThreadTest_4 run......
ThreadTest_4 run......
ThreadTest_3 run......
ThreadTest_3 run......
ThreadTest_3 run......
ThreadTest_2 run......
ThreadTest_2 run......
ThreadTest_2 run......

在main方法中咱们建立了一个String对象lock，并将这个对象赋予每个ThreadTest2线程对象的私有变量lock。咱们知道java中存在一个字符串池，那么这些线程的lock私有变量实际上指向的是堆内存中的同一个区域，即存放main函数中的lock变量的区域，因此对象锁是惟一且共享的。线程同步！！

在这里synchronized锁住的就是lock这个String对象。

对于同步方法块，锁是Synchonized括号里配置的对象。

public class ThreadTest_03 extends Thread{

    public synchronized static void test(){
        for(int i = 0 ; i < 3 ; i++){
            System.out.println(Thread.currentThread().getName() + " run......");
        }
    }
    
    @Override
    public void run() {
        test();
    }

    public static void main(String[] args) {
        for(int i = 0 ; i < 5 ; i++){
            new ThreadTest_03().start();
        }
    }
}

运行结果：

Thread-0 run......
Thread-0 run......
Thread-0 run......
Thread-4 run......
Thread-4 run......
Thread-4 run......
Thread-1 run......
Thread-1 run......
Thread-1 run......
Thread-2 run......
Thread-2 run......
Thread-2 run......
Thread-3 run......
Thread-3 run......
Thread-3 run......

在这个实例中，run方法使用的是一个同步方法，并且是static的同步方法，那么这里synchronized锁的又是什么呢？咱们知道static超脱于对象以外，它属于类级别的。因此，对象锁就是该静态放发所在的类的Class实例。因为在JVM中，全部被加载的类都有惟一的类对象，在该实例当中就是惟一的 ThreadTest_03.class对象。无论咱们建立了该类的多少实例，可是它的类实例仍然是一个！因此对象锁是惟一且共享的。线程同步！！

对于静态同步方法，锁是当前对象的Class对象。

若是一个类中定义了一个synchronized的static函数A，也定义了一个synchronized的instance函数B，那么这个类的同一对象Obj,在多线程中分别访问A和B两个方法时，不会构成同步，由于它们的锁都不同。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

锁的升级

java中锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态，它会随着竞争状况逐渐升级。锁能够升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提升得到锁和释放锁的效率。下面主要部分主要是对博客：聊聊并发（二）Java SE1.6中的Synchronized的总结。

锁自旋

咱们知道在当某个线程在进入同步方法/代码块时若发现该同步方法/代码块被其余如今所占，则它就要等待，进入阻塞状态，这个过程性能是低下的。

在遇到锁的争用或许等待事，线程能够不那么着急进入阻塞状态，而是等一等，看看锁是否是立刻就释放了，这就是锁自旋。锁自旋在必定程度上能够对线程进行优化处理。

偏向锁

偏向锁主要为了解决在没有竞争状况下锁的性能问题。在大多数状况下锁锁不只不存在多线程竞争，并且老是由同一线程屡次得到，为了让线程得到锁的代价更低而引入了偏向锁。当某个线程得到锁的状况，该线程是能够屡次锁住该对象，可是每次执行这样的操做都会由于CAS（CPU的Compare-And-Swap指令）操做而形成一些开销消耗性能，为了减小这种开销，这个锁会偏向于第一个得到它的线程，若是在接下来的执行过程当中，该锁没有被其余的线程获取，则持有偏向锁的线程将永远不须要再进行同步。

当有其余线程在尝试着竞争偏向锁时，持有偏向锁的线程就会释放锁。

锁膨胀

多个或屡次调用粒度过小的锁，进行加锁解锁的消耗，反而还不如一次大粒度的锁调用来得高效。

轻量级锁

轻量级锁能提高程序同步性能的依据是“对于绝大部分的锁，在整个同步周期内都是不存在竞争的”，这是一个经验数据。轻量级锁在当前线程的栈帧中创建一个名为锁记录的空间，用于存储锁对象目前的指向和状态。若是没有竞争，轻量级锁使用CAS操做避免了使用互斥量的开销，但若是存在锁竞争，除了互斥量的开销外，还额外发生了CAS操做，所以在有竞争的状况下，轻量级锁会比传统的重量级锁更慢。

1.5参考资料

一、《Java 7 并发编程实战手册》

二、java synchronized详解

三、聊聊并发（二）Java SE1.6中的Synchronized

四、java的锁机制

五、Java的无锁编程和锁优化