技术点：

1、线程与过程：

在开始之前先把过程与线程进行辨别一下，一个程序起码须要一个过程，而一个过程起码须要一个线程。关系是线程–>过程–>程序的大抵组成构造。所以线程是程序执行流的最小单位，而过程是零碎进行资源分配和调度的一个独立单位。以下咱们所有探讨的都是建设在线程根底之上。

2、Thread的几个重要办法：

咱们先理解一下Thread的几个重要办法。a、start()办法，调用该办法开始执行该线程；b、stop()办法，调用该办法强制完结该线程执行；c、join办法，调用该办法期待该线程完结。d、sleep()办法，调用该办法该线程进入期待。e、run()办法，调用该办法间接执行线程的run()办法，然而线程调用start()办法时也会运行run()办法，区别就是一个是由线程调度运行run()办法，一个是间接调用了线程中的run()办法！！

看到这里，可能有些人就会问啦，那wait()和notify()呢？要留神，其实wait()与notify()办法是Object的办法，不是Thread的办法！！同时，wait()与notify()会配合应用，别离示意线程挂起和线程复原。

这里还有一个很常见的问题，顺带提一下：wait()与sleep()的区别，简略来说wait()会开释对象锁而sleep()不会开释对象锁。这些问题有很多的材料，不再赘述。

3、线程状态：

线程总共有5大状态，通过下面第二个知识点的介绍，了解起来就简略了。

新建状态：新建线程对象，并没有调用start()办法之前

就绪状态：调用start()办法之后线程就进入就绪状态，然而并不是说只有调用start()办法线程就马上变为以后线程，在变为以后线程之前都是为就绪状态。值得一提的是，线程在睡眠和挂起中复原的时候也会进入就绪状态哦。

运行状态：线程被设置为以后线程，开始执行run()办法。就是线程进入运行状态

阻塞状态：线程被暂停，比如说调用sleep()办法后线程就进入阻塞状态

死亡状态：线程执行完结

4、锁类型

可重入锁：在执行对象中所有同步办法不必再次取得锁

可中断锁：在期待获取锁过程中可中断

偏心锁： 按期待获取锁的线程的等待时间进行获取，等待时间长的具备优先获取锁权力

读写锁：对资源读取和写入的时候拆分为2局部解决，读的时候能够多线程一起读，写的时候必须同步地写

synchronized与Lock的区别

1、我把两者的区别分类到了一个表中，不便大家比照：

类别 synchronized Lock
存在档次 Java的关键字，在jvm层面上 是一个类
锁的开释 1、以获取锁的线程执行完同步代码，开释锁 2、线程执行产生异样，jvm会让线程开释锁 在finally中必须开释锁，不然容易造成线程死锁
锁的获取 假如A线程取得锁，B线程期待。如果A线程阻塞，B线程会始终期待 分状况而定，Lock有多个锁获取的形式，具体上面会说道，大抵就是能够尝试取得锁，线程能够不必始终期待
锁状态 无奈判断 能够判断
锁类型 可重入 不可中断 非偏心 可重入 可判断 可偏心（两者皆可）
性能 大量同步 大量同步
或者，看到这里还对LOCK所知甚少，那么接下来，咱们进入LOCK的深刻学习。

Lock具体介绍与Demo

以下是Lock接口的源码，笔者修剪之后的后果：

public interface Lock {    /**     * Acquires the lock.     */    void lock();    /**     * Acquires the lock unless the current thread is     * {@linkplain Thread#interrupt interrupted}.     */    void lockInterruptibly() throws InterruptedException;    /**     * Acquires the lock only if it is free at the time of invocation.     */    boolean tryLock();    /**     * Acquires the lock if it is free within the given waiting time and the     * current thread has not been {@linkplain Thread#interrupt interrupted}.     */    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;    /**     * Releases the lock.     */    void unlock();    }

从Lock接口中咱们能够看到次要有个办法，这些办法的性能从正文中能够看出：
lock()：获取锁，如果锁被暂用则始终期待

unlock():开释锁

tryLock(): 留神返回类型是boolean，如果获取锁的时候锁被占用就返回false，否则返回true

tryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个工夫期限，保障期待参数工夫

lockInterruptibly()：用该锁的取得形式，如果线程在获取锁的阶段进入了期待，那么能够中断此线程，先去做别的事

通过 以上的解释，大抵能够解释在上个局部中“锁类型(lockInterruptibly())”，“锁状态(tryLock())”等问题，还有就是后面子所获取的过程我所写的“大抵就是能够尝试取得锁，线程能够不会始终期待”用了“能够”的起因。

上面是Lock个别应用的例子，留神ReentrantLock是Lock接口的实现。

package com.brickworkers;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LockTest {    private Lock lock = new ReentrantLock();    //须要参加同步的办法    private void method(Thread thread){        lock.lock();        try {            System.out.println("线程名"+thread.getName() + "取得了锁");        }catch(Exception e){            e.printStackTrace();        } finally {            System.out.println("线程名"+thread.getName() + "开释了锁");            lock.unlock();        }    }        public static void main(String[] args) {        LockTest lockTest = new LockTest();                //线程1        Thread t1 = new Thread(new Runnable() {                        @Override            public void run() {                lockTest.method(Thread.currentThread());            }        }, "t1");                Thread t2 = new Thread(new Runnable() {                        @Override            public void run() {                lockTest.method(Thread.currentThread());            }        }, "t2");                t1.start();        t2.start();    }}//执行状况：线程名t1取得了锁//         线程名t1开释了锁//         线程名t2取得了锁//         线程名t2开释了锁

tryLock():

package com.brickworkers;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LockTest {    private Lock lock = new ReentrantLock();    //须要参加同步的办法    private void method(Thread thread){/*        lock.lock();        try {            System.out.println("线程名"+thread.getName() + "取得了锁");        }catch(Exception e){            e.printStackTrace();        } finally {            System.out.println("线程名"+thread.getName() + "开释了锁");            lock.unlock();        }*/                        if(lock.tryLock()){            try {                System.out.println("线程名"+thread.getName() + "取得了锁");            }catch(Exception e){                e.printStackTrace();            } finally {                System.out.println("线程名"+thread.getName() + "开释了锁");                lock.unlock();            }        }else{            System.out.println("我是"+Thread.currentThread().getName()+"有人占着锁，我就不要啦");        }    }        public static void main(String[] args) {        LockTest lockTest = new LockTest();                //线程1        Thread t1 = new Thread(new Runnable() {                        @Override            public void run() {                lockTest.method(Thread.currentThread());            }        }, "t1");                Thread t2 = new Thread(new Runnable() {                        @Override            public void run() {                lockTest.method(Thread.currentThread());            }        }, "t2");                t1.start();        t2.start();    }}//执行后果： 线程名t2取得了锁//         我是t1有人占着锁，我就不要啦//         线程名t2开释了锁

看到这里置信大家也都会应用如何应用Lock了吧，对于tryLock(long time, TimeUnit unit)和lockInterruptibly()不再赘述。前者次要存在一个等待时间，在测试代码中写入一个等待时间，后者次要是期待中断，会抛出一个中断异样，罕用度不高，喜爱探索能够本人深入研究。
后面比拟重提到“偏心锁”，在这里能够提一下ReentrantLock对于均衡锁的定义，在源码中有这么两段：

/**     * Sync object for non-fair locks     */    static final class NonfairSync extends Sync {        private static final long serialVersionUID = 7316153563782823691L;        /**         * Performs lock.  Try immediate barge, backing up to normal         * acquire on failure.         */        final void lock() {            if (compareAndSetState(0, 1))                setExclusiveOwnerThread(Thread.currentThread());            else                acquire(1);        }        protected final boolean tryAcquire(int acquires) {            return nonfairTryAcquire(acquires);        }    }    /**     * Sync object for fair locks     */    static final class FairSync extends Sync {        private static final long serialVersionUID = -3000897897090466540L;        final void lock() {            acquire(1);        }        /**         * Fair version of tryAcquire.  Don't grant access unless         * recursive call or no waiters or is first.         */        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {                if (!hasQueuedPredecessors() &&                    compareAndSetState(0, acquires)) {                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) {                int nextc = c + acquires;                if (nextc < 0)                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }    }

从以上源码能够看出在Lock中能够本人管制锁是否偏心，而且，默认的是非偏心锁，以下是ReentrantLock的构造函数：

 public ReentrantLock() {        sync = new NonfairSync();//默认非偏心锁    }

尾记录：

笔者程度个别，不过此博客在引言中的目标已全副达到。这只是笔者在学习过程中的总结与概括，如存在不正确的，欢送大家批评指出。

延长学习：对于LOCK底层的实现，大家能够参考：
点击Lock底层介绍博客

两种同步形式性能测试，大家能够参考：
点击查看两种同步形式性能测试博客

博主18年3月新增：

回来看本人博客。发现货色论述的不够残缺。这里在做补充，因为这篇博客拜访较大，所以为了不误导大家，尽量介绍给大家正确的表述：
1、两种锁的底层实现形式：
synchronized：咱们晓得java是用字节码指令来控制程序（这里不包含热点代码编译成机器码）。在字节指令中，存在有synchronized所蕴含的代码块，那么会造成2段流程的执行。

咱们点击查看SyncDemo.java的源码SyncDemo.class，能够看到如下：


如上就是这段代码段字节码指令，没你想的那么难吧。言归正传，咱们能够清晰段看到，其实synchronized映射成字节码指令就是减少来两个指令：monitorenter和monitorexit。当一条线程进行执行的遇到monitorenter指令的时候，它会去尝试取得锁，如果取得锁那么锁计数+1（为什么会加一呢，因为它是一个可重入锁，所以须要用这个锁计数判断锁的状况），如果没有取得锁，那么阻塞。当它遇到monitorexit的时候，锁计数器-1，当计数器为0，那么就开释锁。

那么有的敌人看到这里就纳闷了，那图上有2个monitorexit呀？马上答复这个问题：下面我以前写的文章也有表述过，synchronized锁开释有两种机制，一种就是执行完开释；另外一种就是发送异样，虚拟机开释。图中第二个monitorexit就是产生异样时执行的流程，这就是我结尾说的“会有2个流程存在“。而且，从图中咱们也能够看到在第13行，有一个goto指令，也就是说如果失常运行完结会跳转到19行执行。

这下，你对synchronized是不是理解的很清晰了呢。接下来咱们再聊一聊Lock。

Lock：Lock实现和synchronized不一样，后者是一种乐观锁，它胆子很小，它很怕有人和它抢吃的，所以它每次吃货色前都把本人关起来。而Lock呢底层其实是CAS乐观锁的体现，它无所谓，他人抢了它吃的，它从新去拿吃的就好啦，所以它很乐观。具体底层怎么实现，博主不在细述，有机会的话，我会对concurrent包上面的机制好好和大家说说，如果面试问起，你就说底层次要靠volatile和CAS操作实现的。

当初，才是我真正想在这篇博文前面加的，我要说的是：尽可能去应用synchronized而不要去应用LOCK

什么概念呢？我和大家打个比方：你叫jdk，你生了一个孩子叫synchronized，起初呢，你领养了一个孩子叫LOCK。起初，LOCK刚来到新家的时候，它很乖，很懂事，各个方面都体现的比synchronized好。你很开心，然而你内心深处又有一点淡淡的难过，你不心愿你本人亲生的孩子居然还不如一个领养的孩子灵巧。这个时候，你对亲生的孩子教育更加粗浅了，你想证实，你的亲生孩子synchronized并不会比领养的孩子LOCK差。（博主只是打个比方）

那如何教育呢？
在jdk1.6~jdk1.7的时候，也就是synchronized16、7岁的时候，你作为爸爸，你给他优化了，具体优化在哪里呢：

1、线程自旋和适应性自旋
咱们晓得，java’线程其实是映射在内核之上的，线程的挂起和复原会极大的影响开销。并且jdk官网人员发现，很多线程在期待锁的时候，在很短的一段时间就取得了锁，所以它们在线程期待的时候，并不需要把线程挂起，而是让他无目标的循环，个别设置10次。这样就防止了线程切换的开销，极大的晋升了性能。
而适应性自旋，是赋予了自旋一种学习能力，它并不固定自旋10次一下。他能够依据它后面线程的自旋状况，从而调整它的自旋，甚至是不通过自旋而间接挂起。

2、锁打消
什么叫锁打消呢？就是把不必要的同步在编译阶段进行移除。
那么有的小伙伴又迷糊了，我本人写的代码我会不晓得这里要不要加锁？我加了锁就是示意这边会有同步呀？
并不是这样，这里所说的锁打消并不一定指代是你写的代码的锁打消，我打一个比如：
在jdk1.5以前，咱们的String字符串拼接操作其实底层是StringBuffer来实现的（这个大家能够用我后面介绍的办法，写一个简略的demo，而后查看class文件中的字节码指令就分明了），而在jdk1.5之后，那么是用StringBuilder来拼接的。咱们思考后面的状况，比方如下代码：

String str1="qwe";String str2="asd";String str3=str1+str2;

底层实现会变成这样：

StringBuffer sb = new StringBuffer();sb.append("qwe");sb.append("asd");

咱们晓得，StringBuffer是一个线程平安的类，也就是说两个append办法都会同步，通过指针逃逸剖析（就是变量不会外泄），咱们发现在这段代码并不存在线程平安问题，这个时候就会把这个同步锁打消。

3、锁粗化
在用synchronized的时候，咱们都考究为了防止大开销，尽量同步代码块要小。那么为什么还要加粗呢？
咱们持续以下面的字符串拼接为例，咱们晓得在这一段代码中，每一个append都须要同步一次，那么我能够把锁粗化到第一个append和最初一个append（这里不要去纠结后面的锁打消，我只是打个比方）

4、轻量级锁

5、偏差锁