线程与锁

1、Java中，线程的6种状况：

2、开释锁的操作: 1.当时线程的同步办法、同步代码块履行完毕。 2.当时线程在同步代码块、同步办法中遇到break、return停止 了该代码块、该办法的持续履行。 3.当时线程在同步代码块、同步办法中呈现了未处理的Error或Exception,导致反常完毕。 4.当时线程在同步代码块、同步办法中履行了线程目标的wait()办法，当时线程暂停，并开释锁。

不会开释锁的操作: 1.线程履行同步代码块或同步办法时，程序调用Thread. sleep()、Thread.yield()办法暂停当时线程的履行 2.线程履行同步代码块时，其他线程调用了该线程的suspend()办法将该线程挂起，该线程不会开释锁(同步监视器)。 被 3、死锁的必要条件：互斥（资源只能被一个进程占用）；请求和坚持（进程保留已有资源并且还会请求新的资源）；不行掠夺；循环等候。有序资源分配法，银行家算法能够处理死锁。

4、活锁，两个线程不断的获取锁，开释锁，而没有做任何实际的事务操作，死锁是直接进入了等候状况，不能持续了。能够经过增加一个恰当的Thread.sleep来处理这个问题。

线程AB 锁1,2
A(1)<2>--()()--(1)<2>--()()--(1)<2>--()()--(1)<2>--()()--(1)<2>--()()--(1)<2>
B(2)<1>--()()--(2)<1>--()()--(2)<1>--()()--(2)<1>--()()--(2)<1>--()()--(2)<1>

只有当二者正确的获取到锁的次序时才干正常履行，比方A，应该获取到所得次序时2,1，才干持续履行。

CAS的基本原理

CAS（compare and swap）由CPU确保，必定是原子性的。Automic都是由CAS完成的。synchronized也是原子操作。

CAS的问题

（1）ABA问题，变量在不同的线程，比方有两个线程1,2，一个变量的初始值为A，1线程想将这个支撑从A改为B， 2线程首要履行了，将变量从A变成B，又变成A，能够经过增加标志来完成ABA问题的处理，例如版本戳的办法；（2）开销问题：线程不歇息，不断地重复获取最新的值并且核算；（3）只能确保一个同享变量的原子操作。假如是针对一个代码块，是不支撑的。此刻用加锁机制更适合。

失望锁和达观锁

失望锁（有人会改东西，所以抢先获取，synchronize便是典型）；达观锁（片面以为没有改，假如改了咱们就从头来）。

功能比较：

堵塞行列与线程池

堵塞行列（BlockingQueue）

堵塞行列（BlockingQueue）分为有界与无界，这两个表明堵塞行列是否有容量约束。无界表明容量无约束。处理了出产者与顾客的耦合问题，平衡了出产者和顾客的功能均衡问题。DelayQueue，有延时api，在放入元素时会根据放入的时长来决议应该放置的方位。一起在堵塞情况下，在假如剩下的时刻没有到，就不能获取这个元素。SynchronousQueue，不存放任何元素的堵塞行列，出产者出产完了，直接就给顾客消费了。LinkedTransferQueue供给了一种高效的等候-通知机制，答应出产者线程和顾客线程在必要时进行直接的交接，利用的事他里面的transfer办法。

线程池

public ThreadPoolExecutor(int corePoolSize, // 中心线程数
                          int maximumPoolSize,// 最大支撑的线程数量
                          long keepAliveTime, // 非中心线程存活时刻
                          TimeUnit unit, // 时刻单位
                          BlockingQueue<Runnable> workQueue, // 堵塞行列
                          ThreadFactory threadFactory, // 创建线程的办法
                          RejectedExecutionHandler handler // 回绝战略) {

线程对操作系统来说是贵重的资源。线程池自带的四种回绝战略：1、DiscardOldestPolicy，丢掉最老的；2、直接抛出反常；3、哪个线程提交的使命，就由他履行；4、把最新的提交使命直接丢掉。 threadFactory也很少运用，一般的，咱们用它来给线程设置一个姓名。

向线程池提交使命的两种办法

submmit能够回来结果，execute无回来结果。

线程池的关闭办法

shotDown（将一切没有履行线程立刻中止,一般都会成功），shotDownNow（将一切的线程悉数中止，可是不必定成功，线程的中止，线程是一种协作机制，完全看使命是怎样处理中止信号的）。参阅Interrupt办法调用。

合理的装备线程池

合理的装备线程池的参数：需求区分使命的特性。使命有类型：

（1）CPU密集型（纯核算比例很高）：最大线程数量，机器的CPU中心数，最多+1，+1原因是操作系统会把磁盘的一部分拿出来作为虚拟内存，虚拟内存或许导致页缺失，由于调度虚拟内存的数据到内存中，这个或许适当耗时，这便是页缺失，导致线程闲暇。操作系统为了避免CPU闲暇。因而能够+1；

（2）IO密集型（网络通信，读写磁盘）；机器的中心数 * 2；确保CPU能够一向忙碌。

（3）混合型：假如两者差距不大，能够考虑拆分红两个线程池；假如时刻差距太大，就能够不用拆分了，由于大部分时刻都在等候。

IO操作：基本上不用CPU，现代核算机一般都会停工DMA，直接拜访内存机制，CPU操作IO操作的时分，会给磁盘操控器或者网络操控器，发送信号，告知他们要做什么事情，做完了通知CPU，发出一个中止信号,让CPU接手。

零复制：现代一切的程序都是运转在OS上边。现代OS都提出了内核空间与用户空间。用户应用程序是肯定不答应拜访内核空间。硬件设备，应用程序也是不答应拜访的，都是由OS供给的笼统接口。但这儿有个问题，便是存在两次复制的问题，第一次是从操作系统的内存复制到用户内存，第二次又是将操作完成的数据复制到操作系统。为了处理这个问题，答应应用程序想操作系统独自请求一块空间，数据都往这个空间里面放和操作。不再进行复制，这便是零复制的概念。运用了这个的办法有：mmap，directmemory。

AQS与JMM

1、AQS AbstractQueuedSynchronizer；最要害的一个变量：围绕state打转。为什么咱们自己完成的同步东西类，没有感觉到任何的AQS的存在？由于AQS的运用一般是经过承继，咱们一般在同步东西类的内部界说一个内部类，这个内部类承继AQS，这个同步东西对外暴露的办法都是经过这个内部类完成。同步东西类必须要咱们复写tryAquire(独占)，tryAquireShared（同享），一切的显示锁都是承继自Lock接口。假如要自己完成Lock接口的话，lock与unlock都必须完成。

/*取得锁*/
@Override
protected boolean tryAcquire(int arg) {
    if (compareAndSetState(0, 1)) { // 回来true表明拿到了锁。
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}
/*开释锁*/
@Override
protected boolean tryRelease(int arg) {
    if (getState() == 0) {
        throw new IllegalMonitorStateException();
    }
    setExclusiveOwnerThread(null);
    setState(0); // 开释锁。
    return true;
}

AQS的基本思想：CLH行列锁

CLH行列锁。节点自旋，检测前边的节点是否现已开释了锁。假如前边的节点的locked = false，说明前边的节点开释了锁，A线程就能够获取锁了，线程B会在线程A的Locked上边不断地CAS，来承认是否现已开释了锁。但凡要拿到锁的线程，都被打包成一个QNode，至少有3个变量，当时线程自身；myPred，指向我的前驱节点；locked，表明我当时需求取得锁。

公正锁和非公正锁

非公正锁与公正锁的唯一不同便是有没有去判别是否参加CLH行列。非公正，直接去抢占。

锁的可重入

可重入锁：不仅仅是递归，避免产生自己把自己锁住的问题。我拿到锁了，可是我不知道自己拿了锁了，怎么让锁完成可重入？便是经过挂号咱们拿锁的次数，每一次进来就加一次。比及state变成0之后，就能够知道锁现已被我开释了。

// 假如对错重入锁，会导致一向卡在这个办法里面。
protected boolean tryAcquire(int arg) {
    if (compareAndSetState(0, 1)) { // 回来true表明拿到了锁。
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

改为可重入锁：

public boolean tryAcquire(int acquires) {
    if (compareAndSetState(0, 1)) {
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }else if(getExclusiveOwnerThread()==Thread.currentThread()){
        // 表明我有拿了一次锁。
        setState(getState()+1);
        return  true;
    }
    return false;
}
/* 开释锁，将状况设置为0*/
protected boolean tryRelease(int releases) {
    if(getExclusiveOwnerThread()!=Thread.currentThread()){
        throw new IllegalMonitorStateException();
    }
    if (getState() == 0)
        throw new IllegalMonitorStateException();
    // 每开释一次锁，就-1.
    setState(getState()-1);
    if(getState()==0){
        setExclusiveOwnerThread(null);
    }
    return true;
}

JMM模型

JMM模型规则：线程不答应拜访主内存，也不答应拜访其他线程的内存。

JMM导致的并发安全问题

或许会导致数据线程不安全的问题：

volitale

JDK供给的最轻量级的同步机制，确保了数据能够及时刷新到主内存中。 volitale完成禁止指令重排序，确保可见性这两个好处。valitale无法确保原子性(i++这种就不是原子操作)。因而多线程操作肯定会出问题。

可见性：对一个volatile变量的读，总是能看到(恣意线程)对这个volatile变量最后的写入。

原子性:对恣意单个volatile变量的读/写具有原子性，但类似于i++这种复合操作不具有原子性。

Volitale +CAS在一些情况下能够替换掉重量级锁。 一个线程写，多个线程读的也需求用valitale，由于valitale能够强制将变量刷新到主内存，这样才干取到最新的。

volatile的底层原理

倾向锁->轻量级锁->重量级锁

一个线程被block住之后，会被挂起，会产生两次上下文切换。3~5ms。第一次是从运转态到挂起，挂起之后恢复又是一次切换。这些切换很耗费时刻。为了处理这些问题，就引进了倾向锁，轻量级锁，重量级锁。

Synchronized的锁升级流程：

（1）倾向锁：线程拿锁的进程中，锁的取得者总是倾向于第一个获取锁的线程。同一个锁，总是同一个线程获取一把锁。这儿面咱们连CAS都不做了。我检查一下上一个拿到这个线程的是不是我自己，是我自己，直接进入同步块。进行履行，假如大多数情况下，锁不存在线程竞争，用倾向锁的功能是最高的，一旦有了竞争。倾向锁会引进额定的操作，咱们需求禁止运用倾向锁。呈现竞争就升级为轻量级锁。

（2）轻量级锁：经过CAS操作加锁和解锁。咱们推测前一拿到锁的线程或许很快开释锁，咱们没必要履行线程挂起，而是经过CAS操作，不断的自旋获取，这就呈现了自旋锁的概念。不断地试，一般自旋的次数都会有约束，假如自旋的时刻现已超越了线程的上下文切换时刻，就不再自旋。这时线程一向在运转。一旦自旋超越必定次数，说明加锁的操作很重，晋级为重量级锁。

（3）适应性自旋锁：自旋的次数进行操控，自旋的次数由虚拟机自行进行判定。现在虚拟机设置的自旋时刻一般是线程上下文切换的时刻。

（4）重量级锁，拿不到锁的线程，堵塞。

留意：倾向锁升级为轻量级锁的时分，倾向锁向轻量级锁转化的进程，需求吊销目标头的一些信息。在倾向锁吊销的时分，也存在stop the world（一切线程暂停，先做垃圾回收） 的现象，这是为了避免修正数据的时分呈现问题。线程B吊销线程A的倾向锁的时分，是需求修正线程A的仓库上的内容。因而需求，目标A的数据是放在栈空间的，现在需求吊销倾向锁，需求修正栈数据。需求线程B跨线程修正线程A的栈数据。替换完成之后再让线程A的运转。

不同锁的对比

Lock是根据AQS完成的，而Synchronized根据JVM来完成的。

Synchronized的完成原理

一些问题

Java主流锁

1、CAS无锁编程的原理是什么？

运用了现代CPU供给的CAS指令。CAS里面的三大问题：ABA问题；开销问题；只能修正简略变量，不能一起修正多个变量（能够用目标包装处理）。

2、ReentrantLock的完成原理

可重入锁（ReentrantLock）是Java并发编程中的一种显式锁完成，它答应同一个线程屡次获取同一把锁。该锁保护了一个计数器，用于跟踪锁的持有次数。当线程首次进入锁时，计数器值增加至1；每逢该线程再次取得锁时，计数器就会增加；每次开释锁时，计数器则减少。当计数器回到0时，锁被开释。

可重入锁背后的中心机制是由AbstractQueuedSynchronizer（AQS）完成的。AQS是Java并发包（java.util.concurrent，JUC）的根底结构之一，不仅仅用于完成可重入锁，还被应用于完成其他并发东西，如CountDownLatch、读写锁（ReadWriteLock）、信号量（Semaphore）等。AQS内部运用一个int类型的变量state来表明同步状况，并保护了一个行列来办理线程的排队获取资源的进程。它是根据CLH（Craig, Landin, and Hagersten）行列锁的一种变体完成，并支撑独占锁和同享锁两种模式，使得AQS能够灵活完成如读写锁的读锁。

若要自界说同步东西类，通常的做法是经过承继AQS并完成其笼统办法来办理同步状况。这儿采用的是模板办法设计模式，即AQS供给了一个算法的结构，让子类能够在不改动算法结构的情况下从头界说算法的某些步骤。开发者只需覆盖几个要害的办法，如tryAcquire、tryRelease、tryAcquireShared和tryReleaseShared等，就能够根据需求修正或保护同步状况，进而完成自界说的同步东西类。

3、Synchronize的完成原理与优化

内置锁，是要害字，非公正锁，运用monitorenter和monitorexit指令，与ReentrantLock的差异，显示锁，供给了拿锁进程可中止，可测验拿锁，除了公正锁，还有非公正锁。 倾向锁–>轻量级锁—>自旋锁–>适应式自旋锁–>重量级锁（一向存在）。还有锁消除（与逃逸剖析比较紧密，对不或许呈现同享的当地放弃锁）、锁粗化（将未加锁的代码参加到两个synchronize中，兼并synchronize，）、逃逸剖析（便是加锁的目标只在某个办法内部运用，会进行优化）。

4、volatile原理与在DCL效果

Volatile不能确保线程安全。在DCL上边的效果是：禁止指令重排序，New一个目标的三步：1内存中分配空间；2空间初始化；3把空间的地址给咱们的引证。虚拟机中存在重排序的工作，把3排在2之前。类加载的时分由虚拟机确保只会让一个类只会加载一次。（2）Valitale只能确保可见性，不能确保原子性。Synchronize内置锁。能够确保有序。

5、sleep、wait、yield 的差异，wait 的线程怎么唤醒它?

Sleep，yield，wait办法的差异：yield让出CPU，wait让当时线程等候，会开释锁，唤醒后获取锁。Yield的和sleep不会开释锁，sleep也能够被中止。这也是为什么咱们需求给sleep加上trycatch代码块。

6、怎么确保三个线程的次序履行？

ABC，C中run调用B的.join（），B中run调用A.join（）。

7、达观锁与失望锁

失望锁（有人会改东西，所以抢先获取，synchronize便是典型）；达观锁（片面以为没有改，假如改了咱们就从头来,一般会运用版本号机制或CAS算法完成）。