2.4.1-线程的基础知识
1.1 实现方法
| 实现方法 | 使用方法 | 示例 |
|---|---|---|
| 继承 Thread 的方法，重写 run 方法。 | 调用 start 方法。 | |
| 调用线程池 execute 方法。 | ||
| 实现 Runnable 接口，实现 run 方法。 | 构造 Thread 类并新建 Thread 对象，调用 Thread 对象的 start 方法。 | |
| 调用线程池 execute 方法。 | ||
| 调用 submit 方法提交。 | ||
| 构造 FutureTask 对象，使用 submit 方法提交。 | ||
| 实现 Callable 接口，实现 call 方法。 | 调用 submit 方法提交。 | |
| 构造 FutureTask 对象，使用 submit 方法提交。 |
1.2 Future & FutureTask
| 方法 | 功能 |
|---|---|
| cancel | 取消任务 |
| isDone | 判断任务是否完成 |
| isCancelled | 是否成功取消 |
| get | 获取任务返回值，该方法会阻塞知道获取到结果。 |
| get(long timeout, TimeUnit unit) |
FutureTask 实现 RunnableFuture 接口，RunnableFuture 继承了 Future 和 Runnable 接口。
public class FutureExample {
public static class MyCallable implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("Do Something in Thread");
Thread.sleep(5000);
return "Done";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService service= Executors.newCachedThreadPool();
Future<String> future=service.submit(new MyCallable());
System.out.println("Do Something in Main");
System.out.println("Result:"+future.get());
}
}
public class FutureTaskExample {
public static class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("Do Something in Thread");
Thread.sleep(5000);
return "Done";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> task=new FutureTask<String>(new MyCallable());
new Thread(task).start();
System.out.println("Do Something in Main");
System.out.println("Result:"+task.get());
}
}
2. 线程的基本信息
| 方法 | 功能 |
|---|---|
| isAlive() | 线程是否还未终止。 |
| getPriority | 获取线程优先级。 |
| setPriority | 设置线程优先级。 |
| getName | 获取线程名。 |
| setName | 设置线程名。 |
| currentThread() | 静态方法，获取当前线程对象。 |
2. 线程的状态和转换方法
2.1 线程的状态
| 状态 | 解释 |
|---|---|
| New | 调用 new Thread() 方法后进入 New 状态。 |
| Runnable(就绪状态) | 调用 .start()方法 New 状态转为 Runnable 状态，锁池状态获得锁 转为 Runnable 状态。 |
| Running（运行状态） | Runnable 获得时间片，转为 Running 状态。 |
| Blocked（阻塞状态） | 包括Waiting,Waiting(time),同步阻塞。 |
| Waiting | 等待阻塞,本线程使用的对象被其他线程调用 o.wait() 方法，线程由 Running 状态转为 Waiting 状态，当 o.notifyAll() 被调用时，转为 Runnable 状态。 |
| Waiting(time) | 调用 wait(time) 后由 Running转为 Waiting(time) 状态。 |
| 同步阻塞 | 等待锁。 |
2.2 状态转换方法
| 方法 | 功能 |
|---|---|
| join（） | 见名知意，加入，Thread 对象的成员方法。 |
| yield（） | 给其他同优先级和高优先级线程让路，Thread 类的静态方法。 |
| wait() | 等待让出锁。 |
| sleep（） | 等待不让锁。 |
3. 线程池的实现
3.1 ThreadPoolExecutor(ExcutorService 的基类) 的构造参数
| 参数 | 概念 |
|---|---|
| corePoolSize | 线程池中的线程数量小于该值时，创建线程执行任务，而不会使用空闲线程。 |
| maxPoolSize | 最大线程数。 |
| keepAliveTime | 线程没有任务执行时最多保持多久的时间终止。 |
| unit | 时间的单位。 |
| workQueue | 阻塞队列，存储等待执行的任务。线程数大于等于 corePoolSize 小于 maxPoolSize 时，该队列未满则将线程放入该队列，满则床创建新线程；如果线程数量大于 maxPoolSize ，且 workQueue 满，使用拒绝策略，有界队列和无界队列。 |
| threadFactory | 线程工厂,提交后 submit 的方法不执行。 |
| rejectHandler | 线程被拒绝时调用的方法。 |
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
3.2 新建线程池对象
| 类 | 方法 | 功能 |
|---|---|---|
| Excutors | newFixedThreadPool | |
| Excutors | newCachedThreadPool | |
| Excutors | newScheduledThreadPool | |
| Excutors | newSingleThreadPool |
3.3 ThreadPoolExecutor 常用方法
| 接口 | 类 | 方法 | 功能 |
|---|---|---|---|
| ThreadPoolExecutor | getTaskCount | 线程池中已执行和未执行的线程总数。 | |
| ThreadPoolExecutor | getCompletedTaskCount | 线程池中已执行，等于结果 1 减去队列中的线程个数。 | |
| ThreadPoolExecutor | getPoolSize | 线程池中现有的线程数。 | |
| ThreadPoolExecutor | getActiveCount | 线程池中正在执行任务的线程数量。 | |
| ExecutorService | shutdown | 等待提交的任务执行完。 | |
| ExecutorService | List shutdownNow() | 不等待任务执行完。 | |
| Executor | void execute(Runnable command) | 参数实现 Runnable 接口，无返回值。 | |
| AbstractExecutorService | Future submit(Callable task) | 参数实现 Callable 接口，返回值类型为 T。 | |
| AbstractExecutorService | Future submit(Runnable task, T result) | ||
| AbstractExecutorService | Future<?> submit(Runnable task) |
4. 线程同步
4.1 CyclicBarrier
4.1.1 功能
CyclicBarrier:某个线程运行到某个之后，该线程停止运行，直到所有的线程都达到这个点，所有线程才能重新运行。线程互相等待，直到准备就绪。如果调用 c.await() 的次数小于 n,线程卡死？
4.1.2 使用步骤
- 主线程调用 new CyclicBarrier(n) 方法创建 CyclicBarrier 对象;
- 构造线程时，将 CyclicBarrier 对象传入。
- 子线程调用 await() 方法，当第 n 个线程调用 await() 方法，所有线程继续执行。
4.2 CountDownLatch
4.2.2 使用步骤
- 主线程调用 new CountDownLatch(n) 方法创建 CountDownLatch 对象。
- 构造线程时，将 CountDownLatch 对象传入。
- 控制主线程调用 await() 方法等待所有子线程完成。
- 在子线程完成任务，调用 countDown() 方法，当 countDown() 方法调用测试等于 n 时，主线程继续执行。
4.3 信号量(Semaphore)
4.3.1 功能
控制同时放行的进程数。
4.3.2 使用步骤
- 主函数使用 Semaphore(int permits,boolean fair) 构造信号量对象，permits 为线程数目，fair 表示是否启用先进先出的原则进行公平调度。
- 构造线程时，将 Semaphore 对象传入。
- 线程执行前，调用 acquire（） 方法获得许可，如果可用许可数大于 0，继续执行，否则阻塞等待。线程可调用
semaphore.availablePermits()方法查看可用许可证数目。 - 线程执行完任务后，调用 semaphore.release() 方法释放许可。
4.5 BlockingQueue
4.6 AQS
原理
