• A需要等待B的结果返回，才能继续运行，那么A、B就是同步的，不是说AB同步执行的意思！！！；
• A不需要等待B的结果返回，就能继续运行就是A、B就是异步的。

二、Java线程

1.创建和运行线程

（1）方法一：通过创建Thread的子类

（6）方法三：FutureTask接口+Thread

• FutureTask是Runnable的实现类，它能够接收 Callable 类型的参数，可以用来处理有返回结果的情况。
  
• FutureTask的原理
  主线程执行过程中可以单开一个子线程去完成某个任务，完成后子线程返回任务结果给主线程，主线程再继续执行。
  

• 是否有返回值：Callable可以用来处理有返回结果的情况，而Runnable不会返回结果；
• 是否会抛出异常：Callable如果无法计算结果，会抛出异常，而Runnable无法抛出经过检查的异常；
• 最终实现的方法不同：Callable通过call()实现，Runnable通过run()实现。

（8）方法四：线程池——见 九、

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• 在cmd中执行：
  • tasklist：查看所有进程
    
    
  • taskkill：根据PID杀死进程
    

• ps -ef：查看所有进程
• ps -ef | grep 关键字：查找指定关键字的进程
• ps -fT -p <PID>：查看某个进程（PID）的所有线程
• kill PID：杀死进程
• top：动态查看所有进程信息，按大写 H 切换是否显示线程
  
  
• top -H -p <PID>：动态查看某个进程（PID）的所有线程

（3）Java

• jps：查看所有 Java 进程
• jstack <PID>：查看某个 Java 进程（PID）的所有线程状态 
• jconsole：来查看某个 Java 进程中线程的运行情况（图形界面）
  

（1）栈与栈帧 

（2）线程的上下文切换

• 发生线程上下文切换的情况：
  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
• 线程上下文切换时的开销：
  • 当线程发生上下文切换时，需要由操作系统保存当前线程的状态，包括程序计数器(下一条要执行的指令)、栈帧信息(如局部变量、操作数栈、返回地址等)，并恢复另一个线程的状态。
  • 因此频繁发生线程切换会影响系统性能。

（2）start与run的比较

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程；
• 使用 start 是启动新的线程，通过新线程间接执行 run 中的代码。

（3）join的应用

（5）interrupt的应用——两阶段终止模式

5.主线程与子线程、用户线程与守护线程

• 主线程：当 Java 程序启动时，一个线程会立刻运行，该线程通常叫做程序的主线程（main thread）， 即 main 方法对应的线程，它是程序开始时就执行的。
  • 主线程是产生其他子线程的线程。
  • 主线程不一定是最后完成执行的线程，子线程可能在它结束之后还在运行。
• 子线程：在主线程中创建并启动的线程，一般称之为子线程。
  • 用户线程：用户线程通常用来异步处理一些业务或逻辑。主线程结束，用户线程可以继续运行。
  • 守护线程：为主线程提供一些通用服务，比如垃圾回收。主线程结束，守护线程没有了守护的对象，所以守护线程也就结束了。

//线程不安全的list
List<Integer> list=new ArrayList<>();
//支持同步的线程安全list
List<Integer> list=Collections.synchronizedList(new ArrayList<>());

（3）★CopyOnWriteArrayList——写时复制

（4）HashSet和HashMap的线程安全问题及解决方案

• HashSet解决方案——CopyOnWriteArraySet类
• HashMap解决方案——ConcurrentHashMap类
  

• 公平锁：雨露均沾。效率相对较低。
• 非公平锁：可能导致事情都让一个线程干了，其他线程被饿死的情况。但是执行效率高。

public class DeadlockDemo {
    public static void main(String[] args) {
                //o1,o2相当于两个资源
        Object o1 = new Object();
        Object o2 = new Object();
                //线程A拥有o2，想要获取o1
        Thread thread01 = new Thread(() -> {
            synchronized (o2) {
                                //获取到了o2
                try {
                                        //当前线程休眠1秒，保证另外一个线程已经获取到o1
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                                //想要获取o1
                synchronized (o1) {
                    System.out.println("A-ok");
                }
            }
        },"A");
                //线程B拥有o1，想要获取o2
        Thread thread02 = new Thread(() -> {
            synchronized (o1) {
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("B-ok");
                }
            }
        },"B");
        thread01.start();
        thread02.start();
    }
}

• jps -l：类似Linux中的ps -ef命令，可以查看当前程序的所有进程。利用该命令找到当前进程：
  
  
• jstack pid：jvm中自带的堆栈跟踪工具。如果有死锁会在最后有以下提示信息：
  

• 创建读写锁ReadWriteLock对象
  
  
• 加/解读锁

  rwLock.readLock().lock()/unlock();

• 加/解写锁

  rwLock.writeLock().lock()/unlock();

（3）读写锁的降级

• 为什么需要锁降级？
          主要是为了保证数据的可见性。考虑一种场景：线程A修改完后还想查看刚才写的数据：
  -- 没有锁降级：线程A修改完后会直接释放写锁，假设此时线程B获取了写锁并修改了数据，那么线程A再读到的数据就不是自己修改了的数据。
  -- 加了锁降级：线程A修改完释放写锁后紧接着获取读锁，那么线程B将会被阻塞，直到线程A读完数据并释放读锁后，线程B才能获取写锁。

• 当线程调用 await 方法时，该线程会阻塞，直到计数器的值 ≤ 0，该线程才会被唤醒。
• 线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞）。

• acquire()：调用该方法的线程请求获取一个信号量(一个共享资源)，获取不到将阻塞等待，获取到才能执行。
• release()：调用该方法的线程释放信号量(可以通过参数释放多个信号量)。像unlock()一样，一般放在finally块里。

• 在队列为空时，获取元素的线程会阻塞等待，直到队列中有元素；
• 当队列满时，存储元素的线程会阻塞等待，直到队列中有空位。

• ArrayBlockingQueue：基于数组的有界阻塞队列。
          在ArrayBlockingQueue 内部，维护了一个定长数组，以便缓存队列中的数据对象。
• LinkedBlockingQueue：基于链表的有界阻塞队列。
          同 ArrayBlockingQueue 类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue 可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。
          LinkedBlockingQueue 能够高效地处理并发数据，因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。
  

• DelayQueue：基于优先级队列实现的延迟无界阻塞队列。
          DelayQueue 中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue是一个没有大小限制的队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。
• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
          在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁。
• LinkedTransferQueue：基于链表的无界阻塞队列。
• LinkedBlockingDeque：基于链表的双向阻塞队列。
  可以看做无界队列，但也可以设置容量限制，作为有界队列。
  

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

• 线程池中的线程处于一定的范围(固定线程数)，可以很好的控制线程的并发量；
• 线程可以被重复使用，在显示关闭之前，都将一直存在；
• 超出线程池上限的线程被提交时候需要在队列中等待。

• //一池五线程
  ExecutorService threadPool = Executors.newFixedThreadPool(5);

• ExecutorService threadPool = Executors.newCachedThreadPool();
  

ExecutorService threadPool = Executors.newFixedThreadPool(5);

• execute()：直接执行任务，无法获取执行结果。
• submit()：执行任务，并且可以获取执行的结果。

threadPool.execute(Runnable runnable);

• 假设常驻线程=2、最大线程数量=5、阻塞队列=3。现在不断有线程来调用线程池中的线程：
  • 线程池一创建，线程池里就会有2个线程(常驻线程)等待任务到来；
  • 线程1、2调用两个常驻线程；
  • 线程3、4、5想调用时常驻线程正在被调用，那么3、4、5就进入阻塞队列等待；如果常驻线程空闲了，就去阻塞队列中取任务来执行；
  • 线程6、7、8也想调用线程池中的线程，那么线程池就会再创建三个线程(达到最大线程数5了)；当这3个新创建的非常驻线程空闲的时间超过了线程存活时间(keepAliveTime)，这三个非常驻线程就会被释放。
  • 后续线程9、10...还想调用调用线程池中的线程，线程池就会根据拒绝策略拒绝这些线程的调用。
• 拒绝策略：
  
  

• Fork：把一个复杂任务进行拆分；
• Join：把分拆任务的结果进行合并。

• 用runAsync创建：
  
• 用supplyAsync创建：
  
  调用异步对象的get方法获取结果：
  
  

• whenComplete()：等待当前任务执行完后再执行whenComplete()中的任务，且由执行当前任务的线程继续执行 whenComplete 的任务。
  
  【结果】
  
  
• whenCompleteAsync()：与whenComplete()唯一的不同是，执行当前任务的线程与执行whenComplete中任务的线程不是同一个线程，二者是异步的(Async)。
  【tips】如果是使用相同的线程池，也可能会被同一个线程选中执行。
  
• exceptionally()：处理执行过程中的异常。whenComplete()只能感知异常，不能针对异常做出处理，而exceptionally()可以对异常做出处理。
  
  【结果】
  
  

• 比如我们可以在有结果没异常时，将结果*2后返回新结果；在没结果有异常时返回一个0：
  
  【无异常的结果】int i = 10 / 4;
          
  【有异常的结果】
          
  

• thenRun()：只要当前任务执行完成，就开始执行 thenRun中的任务，不需要前面的结果。
  
  【结果】
          
  
• thenAccepy()：接收当前任务的处理结果，并进行消费，无返回结果。
  
  【结果】
          
  
• thenApply()：既可以接收当前任务的结果，进行消费处理，又可以将处理后的新结果进行返回。
  
  【结果】
          
  

• runAfterBoth()：组合两个 future，不需要(也不能)获取 future 的结果，只需两个 future 都处理完任务后，再处理runAfterBoth中的任务，无返回值。
  
  【结果】
          
  
• thenAcceptBoth()：组合两个 future，获取两个 future 任务的执行结果，然后处理thenAcceptBoth中的任务，无返回值。
  
  【结果】
          
  
• thenCombine()：组合两个 future，获取两个 future 的执行结果，并返回thenCombine处理的新结果。
  
  【结果】
          
  

• runAfterEither()：两个任务有一个执行完成，不需要获取 future 的结果，就可以处理任务，无返回值。
  
• acceptEither()：两个任务有一个执行完成，获取该任务的返回值，处理任务，无返回值。
  
• applyToEither()：两个任务有一个执行完成，获取该任务的返回值，处理任务并返回新的结果。
  

• allOf()：等待所有任务完成再执行新任务；
  
  【结果】
          
• anyOf()：只要有一个任务完成就可以执行新任务，有返回值，返回值是任务完成的那个结果。
  
  【结果】