互联网架构多线程并发编程高级教程（上）

基础篇幅：
线程基础知识、并发安全性、JDK锁相关知识、线程间的通讯机制、
JDK提供的原子类、并发容器、线程池相关知识点
 

高级篇幅：
ReentrantLock源码分析、对比两者源码，更加深入理解读写锁，JAVA内存模型、先行发生原则、指令重排序
 
环境说明：
    idea、java8、maven
 

第一章 并发简介
    01 课程简介

        为什么要学习并发编程？
            方便实际开发
                面试
                课程特点
                适合群体

    02    什么是并发编程

        并发历史:
            早期计算机--从头到尾执行一个程序，资源浪费
            操作系统出现--计算机能运行多个程序，不同的程序在不同的单独的进程中运行
            一个进程，有多个线程
                提高资源的利用率，公平

        串行与并行的区别:
            串行：洗茶具、打水、烧水、等水开、冲茶
            并行：打水、烧水同时洗茶具、水开、冲茶

            好处：可以缩短整个流程的时间

        并发编程目的：
            摩尔定律：当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。这一定律揭示了信息技术进步的速度。
            让程序充分利用计算机资源
            加快程序响应速度（耗时任务、web服务器）
            简化异步事件的处理

        什么时候适合使用并发编程:
            任务会阻塞线程，导致之后的代码不能执行：比如一边从文件中读取，一边进行大量计算的情况
            任务执行时间过长，可以划分为分工明确的子任务：比如分段下载
            任务间断性执行：日志打印
            任务本身需要协作执行：比如生产者消费者问题

    03    并发编程的挑战之频繁的上下文切换

        cpu为线程分配时间片，时间片非常短（毫秒级别），cpu不停的切换线程执行，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这    个任务的状态，让我们感觉是多个程序同时运行的

        上下文的频繁切换，会带来一定的性能开销

        如何减少上下文切换的开销？
        无锁并发编程
                无锁并发编程。多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一
                些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据
        CAS
            Java的Atomic包使用CAS算法来更新数据，而不需要加锁。

        使用最少线程。
                避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这
                样会造成大量线程都处于等待状态。
        协程
                在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。--GO

    04 并发编程的挑战之死锁
        package com.xdclass.synopsis;

      

  /**
         * 死锁Demo
         */
        public class DeadLockDemo {
            private static final Object HAIR_A = new Object();
            private static final Object HAIR_B = new Object();

            public static void main(String[] args) {
                new Thread(()->{
                    synchronized (HAIR_A) {
                        try {
                            Thread.sleep(50L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (HAIR_B) {
                            System.out.println("A成功的抓住B的头发");
                        }
                    }
                }).start();

                new Thread(()->{
                    synchronized (HAIR_B) {
                        synchronized (HAIR_A) {
                            System.out.println("B成功抓到A的头发");
                        }
                    }
                }).start();
            }
        }

　　

    05 并发编程的挑战之线程安全

        

package com.xdclass.synopsis;

        import java.util.concurrent.CountDownLatch;

        /**
         * 线程不安全操作代码实例
         */
        public class UnSafeThread {

            private static int num = 0;

            private static CountDownLatch countDownLatch = new CountDownLatch(10);

            /**
             * 每次调用对num进行++操作
             */
            public static void inCreate() {
                num++;
            }

            public static void main(String[] args) {
                for (int i = 0; i < 10; i++) {
                    new Thread(()->{
                        for (int j = 0; j < 100; j++) {
                            inCreate();
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        //每个线程执行完成之后，调用countdownLatch
                        countDownLatch.countDown();
                    }).start();
                }

                while (true) {
                    if (countDownLatch.getCount() == 0) {
                        System.out.println(num);
                        break;
                    }
                }
            }
        }

　　

    06 并发编程的挑战之资源限制

        硬件资源
            服务器： 1m
            本机：2m

            带宽的上传/下载速度、硬盘读写速度和CPU的处理速度。

        软件资源
            数据库连接 500个连接  1000个线程查询  并不会因此而加快
            socket

第二章----线程基础
    01 进程与线程的区别

        
        进程：是系统进行分配和管理资源的基本单位

        线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。    

        一个程序至少一个进程，一个进程至少一个线程。

        进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。
        而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
        线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。
        如何处理好同步与互斥是编写多线程程序的难点。
        多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，
        而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程    出现问题，进而导致整个程序出现问题

    02 线程的状态及其相互转换

        初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
        运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
        阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
        等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
        超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，
        它可以在指定的时间内自行返回。
        终止(TERMINATED)：表示该线程已经执行完毕。

    03 创建线程的方式（上）

        1.继承Thread，并重写父类的run方法
        2.实现Runable接口，并实现run方法
        实际开发中，选第2种：java只允许单继承
        增加程序的健壮性，代码可以共享，代码跟数据独立

    04 创建线程的方式（下）

        1.使用匿名内部类
        2.Lambda表达式
        3.线程池

    05 线程的挂起跟恢复

        什么是挂起线程？
            线程的挂起操作实质上就是使线程进入“非可执行”状态下，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行。
            在线程挂起后，可以通过重新唤醒线程来使之恢复运行

        为什么要挂起线程？
            cpu分配的时间片非常短、同时也非常珍贵。避免资源的浪费。

        如何挂起线程？
            被废弃的方法
                thread.suspend() 该方法不会释放线程所占用的资源。如果使用该方法将某个线程挂起，则可能会使其他等待资源的线程死锁
                thread.resume() 方法本身并无问题，但是不能独立于suspend()方法存在
            可以使用的方法
                wait() 暂停执行、放弃已经获得的锁、进入等待状态
                notify() 随机唤醒一个在等待锁的线程
                notifyAll() 唤醒所有在等待锁的线程，自行抢占cpu资源
        什么时候适合使用挂起线程？
            我等的船还不来(等待某些未就绪的资源)，我等的人还不明白。直到notify方法被调用

    06 线程的中断操作

        stop() 废弃方法，开发中不要使用。因为一调用，线程就立刻停止，此时有可能引发相应的线程安全性问题
        Thread.interrupt方法
        自行定义一个标志，用来判断是否继续执行

    07 线程的优先级

        线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。    但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。

        线程的优先级设置可以为1-10的任一数值，Thread类中定义了三个线程优先级，分别是：
        MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10），一般情况下推荐使用这几个常量，不要自行设置数值。

        不同平台，对线程的优先级的支持不同。     编程的时候，不要过度依赖线程优先级，如果你的程序运行是否正确取决于你设置的优先级是否按所设置的优先级运行，那这样的程序不正确

        任务：
            快速处理：设置高的优先级
            慢慢处理：设置低的优先级

    08 守护线程

        线程分类
            用户线程、守护线程
            守护线程：任何一个守护线程都是整个程序中所有用户线程的守护者，只要有活着的用户线程，守护线程就活着。当JVM实例中最后一个非守护线程结束时，也随JVM一起退出

            守护线程的用处：jvm垃圾清理线程

        建议： 尽量少使用守护线程，因其不可控
              不要在守护线程里去进行读写操作、执行计算逻辑

 

第三章----线程安全性问题

    01 什么是线程安全性？

        当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。----《并发编程实战》

        什么是线程不安全？
            多线程并发访问时，得不到正确的结果。

    02 从字节码角度剖析线程不安全操作

       javac -encoding UTF-8 UnsafeThread.java 编译成.class
       javap -c UnsafeThread.class 进行反编译，得到相应的字节码指令

       0: getstatic     #2               获取指定类的静态域，并将其押入栈顶
       3: iconst_1                         将int型1押入栈顶
       4: iadd                             将栈顶两个int型相加，将结果押入栈顶
       5: putstatic     #2               为指定类静态域赋值
       8: return

       例子中，产生线程不安全问题的原因：
               num++ 不是原子性操作，被拆分成好几个步骤，在多线程并发执行的情况下，因为cpu调度，多线程快递切换，有可能两个同一时刻都读取了同一个num值，之后对它进行+1操作，导致线程安全性。

    03 原子性操作

        什么是原子性操作
            一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
            A想要从自己的帐户中转1000块钱到B的帐户里。那个从A开始转帐，到转帐结束的这一个过程，称之为一个事务。在这个事务里，要做如下操作：
            1. 从A的帐户中减去1000块钱。如果A的帐户原来有3000块钱，现在就变成2000块钱了。
            2. 在B的帐户里加1000块钱。如果B的帐户如果原来有2000块钱，现在则变成3000块钱了。
            如果在A的帐户已经减去了1000块钱的时候，忽然发生了意外，比如停电什么的，导致转帐事务意外终止了，而此时B的帐户里还没有增加1000块钱。
            那么，我们称这个操作失败了，要进行回滚。回滚就是回到事务开始之前的状态，也就是回到A的帐户还没减1000块的状态，B的帐户的原来的状态。
            此时A的帐户仍然有3000块，B的帐户仍然有2000块。
            通俗点讲：操作要成功一起成功、要失败大家一起失败

        如何把非原子性操作变成原子性
            volatile关键字仅仅保证可见性，并不保证原子性
            synchronize关机字，使得操作具有原子性

    04 深入理解synchronized

        内置锁
            每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

        互斥锁
            内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

        修饰普通方法：锁住对象的实例
        修饰静态方法：锁住整个类
        修饰代码块： 锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容

    05 volatile关键字及其使用场景

        能且仅能修饰变量
        保证该变量的可见性，volatile关键字仅仅保证可见性，并不保证原子性
        禁止指令重排序

        A、B两个线程同时读取volatile关键字修饰的对象
        A读取之后，修改了变量的值
        修改后的值，对B线程来说，是可见

        使用场景
            1：作为线程开关
            2：单例，修饰对象实例，禁止指令重排序

       06 单例与线程安全

           饿汉式--本身线程安全
            在类加载的时候，就已经进行实例化，无论之后用不用到。如果该类比较占内存，之后又没用到，就白白浪费了资源。

           懒汉式 -- 最简单的写法是非线程安全的
               在需要的时候再实例化

       07 如何避免线程安全性问题

           线程安全性问题成因
               1：多线程环境
               2：多个线程操作同一共享资源
               3：对该共享资源进行了非原子性操作

           如何避免
               打破成因中三点任意一点
                   1：多线程环境--将多线程改单线程（必要的代码，加锁访问）
                   2：多个线程操作同一共享资源--不共享资源（ThreadLocal、不共享、操作无状态化、不可变）
                   3：对该共享资源进行了非原子性操作-- 将非原子性操作改成原子性操作（加锁、使用JDK自带的原子性操作的类、JUC提供的相应的并发工具类）

 

并发编程及原理视频教程，基础理论+实战，由浅入深，层层深入，剖析并发编程原理

更多课程资料可以查看https://xdclass.net/#/coursecatalogue?video_id=17

赠送大量的学习资料以及干货