Java并发编程的艺术笔记

多线程总结

Java内存模型
- volatile
  - 重排序规则［不允许重排序］
    - volatile读＋任何操作
    - 任何操作＋volatile写
    - volatile写+volatile读
- ReentrantLock
  - 实现依赖于Java同步器框架AQS
  - AQS使用一个整型的volatile变量（命名为state）来维护同步状态
  - 这个volatile变量是ReentrantLock内存语义的关键
- concurrent包下的源码通用模式
  - 声明共享变量为volatile
  - 使用CAS的原子条件更新来实现线程间的同步
  - 配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。
  - concurrent包的实现示意图
- DCL方式中singleton被设定为volatile的作用
  - 如果没有volatile修饰singleton，多线程情况下可能导致后来的线程读取了一个未初始化完成的singleton对象 ［过程2和3重排序了］
  - 添加了volatile后，保证了后来的线程读取到的singleton对象一定是初始化完成的。原理是volatile禁止了singleton的引用指向内存空间的操作和初始化操作的重排序。［禁止2和3重排序］
  - 一个线程生成一个singleton的过程
    1.分配对象的内存空间
    2.初始化对象
    3.设置singleton引用指向内存地址
    4.初次访问singleton对象
- 线程
  - 6种状态
    - new
      构建完成，但未调用start()方法
    - runnable
      就绪＋运行的统称
    - blocked
      阻塞于锁
    - waiting
      进入等待状态，需要等待其它线程做一些特定动作(通知or中断)
    - time_waiting
      超时等待
    - terminated
      线程执行完毕
  - 线程间通信方式
    - volatile和synchronized关键字
    - wait()和notify()、notifyAll()机制
      - wait和notify*()方法调用时，需要先对对象加锁
      - 调用对象的wait()方法后，
        1.线程状态由running变为waiting；
        2.当前线程被放到等待队列里面;
        3.释放对象的锁。
      - notify()将同步队列中的一个线程移到阻塞队列中；notifyAll()方法将同步队列中的所有线程移到阻塞队列中。
        ps:线程从同步队列到阻塞队列的状态变化：waiting->blocked
      - 处于阻塞队列中的线程在获取对象的监视器Monitor上，具有同等的优先级，且最终只能有一个线程获取成功。
      - 处于blocked状态的线程只有获取了对象的Monitor后，才能从wait()方法返回。
    - 等待、通知的经典模式［生产者、消费者模式］
      - 实质就是wait和notify的使用
      - 生产者伪代码
        
        Synchronized(对象) { // 更改条件代码 // 唤醒等待线程对象.notifyAll(); }
      - 消费者伪代码
        
        Synchronized(对象) { while (条件不满足) { 对象.wait(); // 释放对象锁 } // 处理逻辑代码 }
    - 管道输入、输出流
```
  import java.io.IOException;
  import java.io.PipedReader;
  import java.io.PipedWriter;
  import java.util.Scanner;

  public class Main {

      public static void main(String[] args) throws IOException {
          Scanner scanner = new Scanner(System.in);
          PipedWriter producter = new PipedWriter(); //1.将信息读入管道
          PipedReader consummer = new PipedReader(); //2.从管道读取信息
          producter.connect(consummer); //3.绑定

          Thread readThread = new Print(consummer);
          readThread.start();
          int resive = 0;
          try {
              while ((resive = scanner.nextInt()) != -1) {
                  producter.write(resive);
              }
          } catch (Exception e) {

          } finally {
              producter.close();
          }

      }

      static class Print extends Thread {
          private PipedReader pipedReader;

          Print(PipedReader pipedReader) {
              this.pipedReader = pipedReader;
          }

          @Override
          public void run() {
              int resive = 0;
              try {
                  while ((resive = pipedReader.read()) != -1) {
                      System.out.println(resive);
                  }
              } catch (IOException e) {

              }
          }
      }
  }
```
    - Thread.join的使用
      - 思想
        主线程main执行过程中，启动了一个新的线程thread，并调用了thread.join()方法，则thead必须等待main线程执行完后，才从其join()方法返回。
      - 线程终止时，会主动调用notifyAll()方法，通知所有等待在改线程对象上的线程。
      - join源码的逻辑结构和生产者/消费者模式一样：
        加锁＋循环＋循环后的逻辑处理。
    - ThreadLocal的使用
- 线程池
  - 使用线程池的优势
    - 消除了频繁创建和消亡线程的系统资源开销
    - 提高相应速度
    - 提高线程的可管理性
  - ThreadPoolExecutor构造函数的参数 [4个构造函数]
    - 公用
      - int corePoolSize
      - int maximumPoolSize
      - long keepAliveTime
        超过核心线程个数的那些空闲线程最长的存活时间
      - TimeUnit unit
      - BlockingQueue workQueue
    - 非公有
      - ThreadFactory threadFactory
        用于executor创建新线程
      - RejectedExecutionHandler handler
  - 处理流程
    核心线程池是否满了->任务队列是否满了->线程池是否满了->抛弃策略
  - 创建线程池＋提交任务＋关闭线程池 code
```
  // 方式1    
  ThreadPoolExecutor executor = new ThreadPoolExecutor(3,10,100, TimeUnit.MILLISECONDS,null);
  Thread task = new Thread();
  executor.execute(task); // 向线程池提交任务.ps:任务类型必须是thread  
  executor.shutdown();// 关闭线程池  
    
  // 方式2  
  ExecutorService executorService = Executors.newFixedThreadPool(10);
  executorService.submit(task);
  executorService.shutdown();   
```
  - Executors.newFixedThreadPool方式默认使用LinkedBlockingQueue作为任务队列
  - Executors.newSingleThreadExecutor()方式默认使用LinkedBlockingQueue作为任务队列
  - Executors.newCachedThreadPool()方式默认使用SynchronousQueue作为任务队列
  - 阻塞队列的介绍
    - ArrayBlockingQueue
      基于数组结构的有界阻塞队列，按照FIFO对元素排序
    - LinkedBlockingQueue
      - 基于链表结构的无界[int最大值]阻塞队列，按照FIFO对元素排序，
      - 吞吐量 > ArrayBlockingQueue
    - SynchronousQueue
      - 一个不存储元素的有界阻塞队列。没有移除操作，则插入操作处于阻塞状态；有移除操作，才进行插入操作。
      - 吞吐量 > LinkedBlockingQueue
- Executor框架
  - java线程和OS内核线程的对应关系：一对一
  - java线程启动时，会创建一个OS的线程；当java线程终止时，OS线程也被回收
  - 任务的两级调度模型
  - Executor框架的使用示意图
  - ScheduledThreadPoolExecutor
    - 继承自ThreadPoolExecutor
    - 用途
      - 定期执行任务
      - 按给定的延迟执行任务
    - 对ThreadPoolExecutor的改进
      - 任务队列使用DelayQueue
      - 获取任务方式不同
        可能添加了放入condition的操作
      - 执行周期任务后，增加了额外的处理
        从队列取出任务后，修改time的值再放入队列
    - DelayQueue中对象RunnableScheduledFutur的属性
      - long型time，表示任务要被执行的具体时间
      - long型sequenceNumber，表示添加到ScheduledThreadPoolExecutor的序号
      - long型period，表示任务执行的间隔周期
    - DelayQueue底层实现为PriorityQueue
      优先级排序规则：time->sequenceNumber依次升序
    - ScheduledThreadPoolExecutor获取任务的过程
    - ScheduledThreadPoolExecutor添加任务的过程

Java并发编程的艺术笔记

多线程总结

猜你喜欢