多线程

• 线程(Thread)是一个程序内部的一条执行流程。
• 程序中如果只有一条执行流程，那这个程序就是单线程的程序。
• 多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）。

创建线程

• 启动线程必须是调用start方法，不是调用run方法。
  • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
  • 只有调用start方法才是启动一个新的线程执行。
• 不要把主线程任务放在启动子线程之前。
  • 这样主线程一直是先跑完的，相当于是一个单线程的效果了。

方式一：继承Thread类

• 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
• 创建MyThread类的对象
• 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
• 优缺点
  • 优点：编码简单
  • 缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

方式二：实现Runable接口

• 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
• 创建MyRunnable任务对象
• 把MyRunnable任务对象交给Thread处理。
• 调用线程对象的start()方法启动线程
• 优缺点
  • 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
  • 缺点：需要多一个Runnable对象。

Thread****类提供的构造器	说明
public Thread(Runnable target)	封装Runnable对象成为线程对象

• 匿名内部类写法
  • 可以创建Runnable的匿名内部类对象。
  • 再交给Thread线程对象。
  • 再调用线程对象的start()启动线程。

方式三：实现Callbale接口

• 创建任务对象
  • 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
  • 把Callable类型的对象封装成FutureTask（线程任务对象）。
• 把线程任务对象交给Thread对象。
• 调用Thread对象的start方法启动线程。
• 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。
• 优缺点
  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
  • 缺点：编码复杂一点。
• FutureTask的API

FutureTask提供的构造器	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。

FutureTask提供的方法	说明
public V get() throws Exception	获取线程执行call方法返回的结果。

Thread的常用方法

Thread提供的常用方法	说明
public void run()	线程的任务方法
public void start()	启动线程
public String getName()	获取当前线程的名称，线程名称默认是Thread-索引
public void setName (String name)	为线程设置名称
public static Thread currentThread ()	获取当前执行的线程对象
public static void sleep(long time)	让当前执行的线程休眠多少毫秒后，再继续执行
public final void join()…	让调用当前这个方法的线程先执行完！

Thread 提供的常见构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target, String name)	封装Runnable对象成为线程对象，并指定线程名称

线程安全

• 多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。
  • 存在多个线程在同时执行
  • 同时访问一个共享资源
  • 存在修改该共享资源

线程同步

• 线程同步是线程安全问题的解决方案。
• 线程同步的核心思想
  • 让多个线程先后依次访问共享资源，这样就可以避免出现线程安全问题。
• 线程同步的常见方案
  • 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

方式一：同步代码块

• 作用：把访问共享资源的核心代码给上锁，以此保证线程安全。
  • 对出现问题的核心代码使用synchronized进行加锁
  • 每次只能一个线程占锁进入访问
• 原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。
• 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。
• 锁对象的使用规范
  • 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象。
  • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

synchronized(同步锁) {访问共享资源的核心代码
}

同步方法

• 作用：把访问共享资源的核心方法给上锁，以此保证线程安全。

• 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

• 如果方法是实例方法：同步方法默认用this作为的锁对象。

• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

修饰符 synchronized 返回值类型 方法名称(形参列表) {操作共享资源的代码
}

方式三：Lock锁

• Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
• Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。
• 锁对象建议使用final修饰，防止被别人篡改
• 释放锁建议将释放锁的操作放到finally代码块中，确保锁用完了一定会被释放

线性池

• 线程池就是一个可以复用线程的技术。
• 不使用线性池的问题
  • 用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的， 创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。
• 线程池的工作原理
  线程池的基本概念是，在应用程序启动时创建一定数量的线程，并将它们保存在线程池中。当需要执行任务时，从线程池中获取一个空闲的线程，将任务分配给该线程执行。当任务执行完毕后，线程将返回到线程池，可以被其他任务复用。
  • 线程池：{有限的任务队列(WorkQueue)}
  • 工作线程WorkThread进行选择任务队列的对象。
  • 任务接口
    • Runable
    • Callable

创建线程池

• JDK 5.0起提供了代表线程池的接口：ExecutorService。
• 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。
  ExecutorService ——> ThreadPoolExecutor
  • 通过ThreadPoolExecutor创建线程池。
    • 参数一：corePoolSize : 指定线程池的核心线程的数量。
    • 参数二：maximumPoolSize：指定线程池的最大线程数量。
    • 参数三：keepAliveTime ：指定临时线程的存活时间。
    • 参数四：unit：指定临时线程存活的时间单位(秒、分、时、天）
    • 参数五：workQueue：指定线程池的任务队列。
    • 参数六：threadFactory：指定线程池的线程工厂。
    • 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

ThreadPoolExecutor类提供的构造器	作用
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)	使用指定的初始化参数创建一个新的线程池对象

• 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

处理Runnable任务

• ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future submit(Callable task)	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池！
List shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

• 线程池的注意事项
  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
    什么时候会拒绝新任务？
  • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。
• 任务拒绝策略

策略	说明
ThreadPoolExecutor.AbortPolicy()	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor. DiscardPolicy()	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor. DiscardOldestPolicy()	抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor. CallerRunsPolicy()	由主线程负责调用任务的run()方法从而绕过线程池直接执行

处理Callable任务

• 线程池使用ExecutorService的方法处理Callable任务，并得到任务执行完后返回的结果。
  Future<T> submit(Callable<T> command)

通过Executors创建线程池

• Executors是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。
• 方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

方法名称	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

• Executors不是适合做大型互联网场景的线程池方案。
  • 建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。

并发/并行

• 正在运行的程序（软件）就是一个独立的进程。
• 线程是属于进程的，一个进程中可以同时运行很多个线程。
• 进程中的多个线程其实是并发和并行执行的。

并发

• 进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行

• 在同一个时刻上，同时有多个线程在被CPU调度执行。