目录

LockSupport（一个线程阻塞的工具类）

park和unpark区别：

总结：

Lock锁

synchronized和Lock的异同：

以下功能是Lock具备，synchronized不具备的。

Lock锁的原理：cas和aqs

并发编程的三大特性：

        CAS：

        AQS：

原子类包：java.util.concurrent.atomic

线程池

为什么要使用线程池？（便于管理，提高性能）

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

线程池中参数的意义（重要）：

常见的工作队列

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

自定义线程池（必须掌握）

 例题

两个线程轮流打印数字，从1-100

写两个线程一个打印1~52，另一个线程打印A~Z，打印顺序：12A，34B。。。5152Z

总结 

LockSupport（一个线程阻塞的工具类）

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

park：停车。如果我们把Thread看成一辆车的话，park就是让车停下

unpark：让车启动然后跑起来

这里的park和unpark其实实现了wait和notify的功能

park和unpark区别：

1. park不需要获取某个对象的锁（不释放锁）
2. 因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，然后做额外的处理。

总结：

1. park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用
2. park和unpark不会出现死锁
3. blocker的作用可以看到阻塞对象的信息

Lock锁

Lock是一个接口

键盘输入和打印输出是极其耗资源的，因为是频繁的IO操作，这两种在实际开发中绝对不允许使用。

如果能用Lock，优先选择Lock，如果Lock太麻烦，选择synchronized代码块，如果synchronized代码块解决不了，使用synchronized方法。

Lock接口的实现类—ReentrantLock

ReentrantLock，可重入锁。实现了Lock接口

synchronized和Lock的异同：

1. Lock是一个接口，synchronized是一个关键字，synchronized是由底层语言（C语言）实现的。
2. Synchronized（自动释放）发生异常时，会自动释放线程占用的锁，不会发生死锁。Lock发生异常（需要手动释放），若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁（调用Lock方法）
3. Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断。
4. Lock可以提高多个线程进行读操作的效率。

以下功能是Lock具备，synchronized不具备的。

ReentrantReadWriteLock：

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

    电商读的多
    车票写的多

Lock锁的原理：cas和aqs

synchronized本质上是由C语言实现的，只能作为关键字来使用

Java提供了一些并发的编程的包，底层的实现原理是cas和aqs

并发编程的三大特性：

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

synchronized  lock ：可以保证原子性、可见性、有序性

        CAS：

compare and swap。比较并交换。JDK11改成了compare and set

 思路；就是给一个元素赋值时，先看看内存里的那个值到底变没变，其实是一个无锁的操作。

        AQS：

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

原子类包：java.util.concurrent.atomic

JUC并发编程包在java.util.concurrent.atomic下

1. 原子类Atomic

AtomicInteger：整型原子类

AtomicLong：长整型原子类

AtomicBoolean：布尔型原子类

数组类型

AtomicLongArray：长整型数组原子类

AtomicIntegerArray：整形数组原子类

AtomicReference：引用数据类型原子类

线程池

为什么要使用线程池？（便于管理，提高性能）

1. 降低资源的消耗。通过重复利用已创建的线程来降低创建和销毁线程造成的资源消耗。
2. 提高响应速度。放任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性。线程时比较稀缺的资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。

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

1. newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活地回收空闲线程。若无可回收的线程，就会创建新线程。
2. newFixedThreadPool：创建一个定长的线程池，可以控制线程最大并发数，超出的线程会在队列中等待。
3. newScheduledThreadPool：创建一个定长的线程池，支持定时及周期性任务执行
4. newSingleThreadExecutor：创建一个单线程华的线程池，它只会用唯一的工作线程来执行任务，可以保证所有的任务都按照指定顺序执行。

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

 

 

线程池中参数的意义（重要）：

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

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

keepAliveTime：当线程池里的线程数量大于核心的大小（corePoolSize），

                        多出辣的空闲线程，多长时间被销毁。

unit（枚举）：时间单位

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

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

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

常见的工作队列

ArrayBlockingQueue：基于数组的有界的阻塞队列。FIFO（先进先出）

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

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

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

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

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

DiscardPolicy：直接丢弃任务

自定义线程池（必须掌握）

*****  1.创建线程的四种方式

****   2.线程同步（synchronized，ReentrantLock，ReentrantReadWriteLock）

*****  3.线程之间的通信（wait，notify，notifyAll）

***    4.线程类的常用方法

指令重排，线程争抢，可见性，原子性，volatile关键字

 例题

两个线程轮流打印数字，从1-100

public class Test01 {

    private static class MyNumberTest {


        private static boolean flag = true;

        // 要打印的数字
        private static int count = 0;

        public synchronized void print1() {
            for (int i = 0; i < 50; i++) {
                while (!flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }
        public synchronized void print2() {
            for (int i = 0; i < 50; i++) {
                while (flag) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "->" + ++count);
                flag = !flag;
                notifyAll();
            }
        }

    }

    public static void main(String[] args) {
        MyNumberTest myNumberTest = new MyNumberTest();
        Thread t1 = new Thread(() -> {
            myNumberTest.print1();
        });
        t1.setName("线程A");
        Thread t2 = new Thread(() -> {
            myNumberTest.print2();
        });
        t2.setName("线程B");

        t1.start();
        t2.start();
    }

}

输出结果：

线程A->1
线程B->2
线程A->3
线程B->4
线程A->5
线程B->6
线程A->7
线程B->8
线程A->9
线程B->10

。。。 

写两个线程一个打印1~52，另一个线程打印A~Z，打印顺序：12A，34B。。。5152Z

public class J8042 {

    public static void main(String[] args) {
        Print print = new Print();
        new Thread(
                () -> {
                    print.print1();
                },"线程1"
        ).start();
        new Thread(
                () -> {
                    print.print2();
                },"线程2"
        ).start();
    }
}



class Print {
    static Integer count = 0;
    static char letter = 'A';
    static boolean flag = true;
    public synchronized void print1(){
        while (count < 52){
            if(!flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(count <= 99)
                System.out.println(Thread.currentThread().getName() + ":" + ++count);
            if(count % 2 == 0){
                this.notify();
                flag = false;
            }
        }
    }
    public synchronized void print2(){
        while (letter <= 'Z' ){
            if (flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(count <= 99)
                System.out.println(Thread.currentThread().getName() + ":" + (char)letter++);
            this.notify();
            flag = true;
        }
    }
}

输出结果：

线程1:1
线程1:2
线程2:A
线程1:3
线程1:4
线程2:B
线程1:5
线程1:6
线程2:C
线程1:7
线程1:8
线程2:D
线程1:9
线程1:10
线程2:E 

。。。

总结 

        今天学习继续深入学习线程，锁的应用更加复杂，听同学说线程-锁 的知识是之后的高薪敲门砖，如果拿下这段知识毕业即可月薪1w（心动了哈哈哈），老师还说了线程池-虽然好用，但是市场应用较少。

        目前的题目主要是线程分开执行，各走各的但是仍有关联（我理解的），可是自从锁之后我就没听懂课上知识，只是简单的做了笔记和理解，我打算课后找些简单的题琢磨琢磨，争取拿下（月薪1w）！