1. 线程的实现
1.1 实现方法
| 实现方法 |
使用方法 |
| 继承 Thread 的方法，重写 run 方法。 |
调用 start 方法。 |
| 实现 Runnable 接口，实现 run 方法。 |
使用该对象构造 Thread 类，调用 Thread 对象的 start 方法。 |
|
调用线程池 execute 方法。 |
|
调用 线程池 execute 方法。 |
|
调用 submit 方法提交。 |
|
构造 FutureTask 对象，使用 submit 方法提交。 |
| 实现 Callable 接口，实现 call 方法。 |
调用 submit 方法提交。 |
1.2 Future & FutureTask
| 方法 |
功能 |
| cancel |
取消任务 |
| isDone |
判断任务是否完成 |
| isCancelled |
是否成功取消 |
| get |
获取任务返回值，该方法会阻塞知道获取到结果。 |
| get(long timeout, TimeUnit unit) |
|
FutureTask 实现 RunnableFuture 接口，RunnableFuture 继承了 Future 和 Runnable 接口。
2. 线程的状态和转换方法
2.1 线程的状态
屏幕快照 2019-03-20 下午6.47.29.png
| 状态 |
解释 |
| New |
调用 new Thread() 方法后进入 New 状态。 |
| Ready(就绪状态) |
调用 .start()方法 New 状态转为 Ready 状态，锁池状态获得锁 转为 Ready 状态。 |
| Running（运行状态） |
Runnable 获得时间片，转为 Running 状态。 |
| Blocked（阻塞状态） |
等待锁。 |
| Waiting |
等待阻塞,本线程使用的对象被其他线程调用 o.wait() ,t.join() ,LockSupport.park() 方法，线程由 Running 状态转为 Waiting 状态，当 o.notifyAll() 被调用时，转为 Runnable 状态。 |
| Waiting(time) |
调用 wait(timeout)、join(timeout)、Thread.sleep(sleepTime),LockSupport.parkNanos() 后由 Running转为 Timed Waiting 状态。 |
| Terminated |
调用 thread.terminated 方法。 |
2.2 状态转换方法
| 方法 |
功能 |
| join（） |
见名知意，加入，Thread 对象的成员方法。 |
| yield（） |
给其他同优先级和高优先级线程让路，线程状态由 Running 转为 Ready，Thread 类的静态方法。 |
| wait(long) |
只能在同步方法中使用,线程状态由 Runnable 转为 Timed Waiting ，等待让出锁，进入对象的等待队列中。 |
| wait() |
只能在同步方法中使用，线程状态由 Runnable 转为 Waiting ，等待让出锁。 |
| notify() |
唤醒 wait 线程，处于该对象等待池中被唤醒的线程进入该对象的锁池中，线程状态由Waiting 转为 Blocked。随机选取一个等待池中的线程，进入锁池去竞争获取锁的机会。 |
| notifyAll() |
让所有处于等待池中的线程，进入锁池去竞争获取锁的机会。 |
| sleep（long） |
可以在任何地方使用，等待不让锁，线程状态由 Runnable 转为 Waiting 。 |
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 |
返回 ThreadPoolExecutor（实现了 ExecutorService 接口） 对象。 |
| Excutors |
newCachedThreadPool |
返回 ThreadPoolExecutor 对象。 |
| Excutors |
newScheduledThreadPool |
返回 ScheduledThreadPoolExecutor（实现了 ScheduledExecutorService 接口） 对象。 |
| Excutors |
newSingleThreadPool |
返回 ThreadPoolExecutor 对象。 |
3.3 线程池的常用方法
线程池继承与实现.png
| 接口/类 |
方法 |
功能 |
| Executor |
void execute(Runnable command) |
参数实现 Runnable 接口，无返回值。 |
| ExecutorService |
shutdown |
等待提交的任务执行完。 |
| ExecutorService |
List<Runnable> shutdownNow() |
不等待任务执行完。 |
| AbstractExecutorService |
Future<T> submit(Callable<T> task) |
参数实现 Callable 接口，返回值类型为 T。 |
| AbstractExecutorService |
Future<T> submit(Runnable task, T result) |
|
|
AbstractExecutorService |
Future<?> submit(Runnable task) |
|
| ThreadPoolExecutor |
getTaskCount |
线程池中已执行和未执行的线程总数。 |
| ThreadPoolExecutor |
getCompletedTaskCount |
线程池中已执行，等于结果 1 减去队列中的线程个数。 |
| ThreadPoolExecutor |
getPoolSize |
线程池中现有的线程数。 |
| ThreadPoolExecutor |
getActiveCount |
线程池中正在执行任务的线程数量。 |
| ScheduledExecutorService |
public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit); |
|
|
public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit); |
|
4. AQS
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.4 BlockingQueue
通过 Lock 和 Condition 实现。
参考资料
网友评论