多线程，锁，线程池

JAVA（多线程，锁，线程池）

一, LockSupport工具类

线程阻塞的工具类，所有方法都是静态方法，可让线程在任意位置阻塞，阻塞后也有唤醒方法

park：停车，把Thread看成一辆车，park就是让车停

unpark：可看作让车启动跑起来

区别：

  都可以实现wait和notify的功能，但不和wait和notify交叉使用

  都不会出现死锁

  blocker的作用看到阻塞对象的信息

package duoxiancheng.suo;

import java.util.concurrent.locks.LockSupport;

/**
 * 这里的park和unpark实现了wait和notify的功能
 * 区别：
 *      park：不需要获取某个对象的锁
 *      中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态
 *      
 */
public class Test16 {
    public static final Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            synchronized (obj) {
                System.out.println(Thread.currentThread().getName());
                //阻塞
                LockSupport.park();
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("被中断...");
//                    LockSupport.unpark();
                }
                System.out.println("继续执行...");
            }
        };
        Thread t1 = new Thread(runnable,"线程1");
        Thread t2 = new Thread(runnable,"线程2");
        t1.start();
        Thread.sleep(1000);
        t2.start();
        Thread.sleep(3000);
        //线程中断
        t1.interrupt();

        LockSupport.unpark(t2);
        t1.join();
        t2.join();

    }
}

 

二，Lock锁（接口）

lock()：加锁

unlock()：释放锁

lock接口的实现类ReentrantLock

ReentrantLock，可重入锁

实现了Lock接口

 

sychronized和Lock的区别

1.Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现

2.synchronized发生异常时，会自动释放线程占用的锁不会发生死锁

  Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁

3.Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断

4.Lock可以提高多个线程进行读操作的效率

 

Lock以下功能时synchronized不具备的

ReentrantReadWriteLock:

  对于一个应用而言，一般情况下读操作多余写操作，如果只是读操作没有写操作，数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但不能有线程写，写时独占的，当有线程在执行的操作，其他线程不能读，也不能写。

 

Lock锁的原理cas和aps

synchronized是由c语言实现的，只能作为关键字使用

java提供了一些并发的编程的包，底层的实现cas和aps

 

三，编发编程三大特性

1.原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，也不可以被切割只执行其中的一部分，将整个操作视为一个整体，原子性不仅仅是多行代码，也可能是多条指令

2.可见性：如一个变量在一个线程的改变，其他线程也能看见

3.有序性：代码的执行顺序

 

CAS：compare and swap，比较并交换。JDK改成了compare and set。

  思路：一个元素赋值时，先看看内存里的那个值到底变没变

AQS：抽象队列同步器，用来解决线程同步执行的问题，是一个双向链表

 

synchronized底层实现

synchronized 属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层操作系统的 Mutex Lock 来实现的，而操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方从 JVM 层面对 synchronized 进行了较大优化，所以现在的 synchronized 锁效率也优化得很不错了。Java 6 之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁，

 

Lock底层实现

Lock底层实现基于AQS实现，采用线程独占的方式，在硬件层面依赖特殊的CPU指令（CAS）。

简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。

• lock的存储结构：一个int类型状态值（用于锁的状态变更），一个双向链表（用于存储等待中的线程）
• lock获取锁的过程：本质上是通过CAS来获取状态值修改，如果当场没获取到，会将该线程放在线程等待链表中。
• lock释放锁的过程：修改状态值，调整等待链表。

 

volatile底层实现

在JVM底层volatile是采用“内存屏障”来实现的。

 

lock和Monitor的区别

一、lock的底层本身是Monitor来实现的，所以Monitor可以实现lock的所有功能。

二、Monitor有TryEnter的功能，可以防止出现死锁的问题，lock没有。

1，自旋锁

自旋锁其实就是在拿锁时发现已经有线程拿了锁，自己如果去拿会阻塞自己，这个时候会选择进行一次忙循环尝试。也就是不停循环看是否能等到上个线程自己释放锁。这个问题是基于一个现实考量的：很多拿了锁的线程会很快释放锁。因为一般敏感的操作不会很多。当然这个是一个不能完全确定的情况，只能说总体上是一种优化。

然后是基于这种做法的一个优化：自适应自旋锁。也就是说，第一次设置最多自旋10次，结果在自旋的过程中成功获得了锁，那么下一次就可以设置成最多自旋20次。道理是：一个锁如果能够在自旋的过程中被释放说明很有可能下一次也会发生这种事。那么就更要给这个锁某种“便利”方便其不阻塞得锁（毕竟快了很多）。同样如果多次尝试的结果是完全不能自旋等到其释放锁，那么就说明很有可能这个临界区里面的操作比较耗时间。就减小自旋的次数，因为其可能性太小了。

2，锁粗化

试想有一个循环，循环里面是一些敏感操作，有的人就在循环里面写上了synchronized关键字。这样确实没错不过效率也许会很低，因为其频繁地拿锁释放锁。要知道锁的取得（假如只考虑重量级MutexLock）是需要操作系统调用的，从用户态进入内核态，开销很大(阿里面试)。于是针对这种情况也许虚拟机发现了之后会适当扩大加锁的范围（所以叫锁粗化）以避免频繁的拿锁释放锁的过程。

3，锁消除

通过逃逸分析发现其实根本就没有别的线程产生竞争的可能（别的线程没有临界量的引用），而“自作多情”地给自己加上了锁。有可能虚拟机会直接去掉这个锁。

4，偏向锁和轻量级锁

这两个锁既是一种优化策略，也是一种膨胀过程所以一起说。首先它们的关系是：最高效的是偏向锁，尽量使用偏向锁，如果不能（发生了竞争）就膨胀为轻量级锁，这样优化的效率不如原来高不过还是一种优化（对比重量级锁而言）。所以整个过程是尽可能地优化。

5,非公平锁

“非公平”即体现在这里，如果占用锁的线程刚释放锁，state置为0，而排队等待锁的线程还未唤醒时，新来的线程就直接抢占了该锁，那么就“插队”了(请注意此处的非公平锁是指新来的线程跟队列头部的线程竞争锁，队列其他的线程还是正常排队

 

四，线程池

为什么使用线程池

1.降低资源消耗，通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗

2.提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行

3.提高线程的客观理性，使用比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

 

JDK自带的四种线程池通过Executors提供

1.newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需求，可以灵活回收空闲线程，若无o可回收，创建新线程。

2.newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出线程会在队列中等待。

3.newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行。

4.newSingleThreadExecutor：创建一个单线程化的线程池，他只会用唯一的工作线程来执行任务，保证所有的任务按照指定的顺序执行。

 

这四种线程池的初始化都调用了同一个构造器：

ThreadPoolExecutor ( int corePoolSize,

            int maximumPoolSize,

            long keepAliveTime,

            TimeUnit unit,

            BlockingQueue<Runnable>  workQueue,

            ThreadFactory  threadFactory,

           RejectedExecutionHandler  handler  )

参数的意义：

corePoolSize：线程池里的线程数量，核心线程池大小

maximumPoolSize：指定了线程池里的最大线程数量

keepAliveTime：当线程池数量大于corePoolSize，多出来的空闲线程，多长时间被销毁

unit：时间单位

workQueue：任务队列，用于存放提交但是尚未被执行的任务

threadFactory：线程工厂，用来创建线程，线程工厂是我们new线程的

handler：拒绝策略，是将任务添加到线程池中时，线程池拒绝该任务多采取的响应的措施

 

常见的工作队列

ArrayBlockingQueue：基于数组的有界阻塞队列。FIFO

LinkBlockingQueue：基于链表的有界阻塞队列。FIFO

 

线程池提供了四种拒绝策略

AbortPolicy：直接抛出异常，默认的策略

CallerRunPolicy：用调用者所在的线程来执行任务

DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务

DiscardPolicy：直接丢弃任务