一, 实现 Java 多线程的方法
1, 继承 Thread 类创建多线程
Thread 类本质实现了 Runnable 接口. 启动线程为 start0() 方法. 是个 native 方法.
- public class ThreadProcess extends Thread {
- @Override
- public void run(){
- long lastTime = System.currentTimeMillis();
- for(int i = 0; i <1; i++){
- int ele = Integer.MAX_VALUE;
- while (ele>= 0){
- int ele2 = ele - Integer.MAX_VALUE + 65535 - 37666 + 44443;
- int temp = Math.max(ele2, ele);
- if(temp != ele){
- temp = ele;
- }
- ele = temp-1;
- }
- }
- System.out.println("Time cost from thread" + (System.currentTimeMillis() - lastTime));
- }
- }
2, 实现 Runnable. 一个类已经继承了 Thread 类就无法继承其它类.
- class AccountOperator implements Runnable {
- private int count;
- private final byte[] lock = new byte[0];
- public AccountOperator() {
- this.count = 0;
- }
- public void run() {
- synchronized (lock) {
- count++;
- System.out.println(Thread.currentThread().getName() + ":" + count);
- }
- }
- }
3, 实现 Callable
如果运行完线程并且需要线程返回结果的时候, 可以
- import java.util.concurrent.Callable;
- public class GetDataThread<V> implements Callable<V> {
- private V v;
- public GetDataThread(V v) {
- this.v = v;
- }
- @Override
- public V call() {
- return this.v;
- }
- }
- public class Main {
- public static void main(String[] args) throws Exception{
- String data = "data";
- FutureTask<String> ft = new FutureTask<>(new GetDataCal<>(data));
- Thread t = new Thread(ft);
- t.start();
- String res = ft.get();
- System.out.println("Result:" + res);
- }
- }
二, Java 线程池
线程的创建和销毁是需要时间的. 记线程创建的时间为 T1, 线程运行的时间为 T2, 线程销毁的时间为 T3. 如果 T1 + T3 远远大于 T2, 并且有很多这样的任务需要并行执行时, 就可以使用线程池.
因为通过线程池, 线程资源可以重复使用.
1, 常见的线程池
- newSingleThreadExecutor
- newFixedThreadExecutor
- newCachedThreadExecutor
- newScheduleThreadExecutor
2, 首先看下 ThreadPoolExecutor 方法. 构造函数包含了几个重要参数,
- public ThreadPoolExecutor(int corePoolSize,
- int maximumPoolSize,
- long keepAliveTime,
- TimeUnit unit,
- BlockingQueue<Runnable> workQueue
- RejectedExecutionHandler handler){}
corePoolSize, 线程池核心线程数量
maximumPoolSize, 线程池最大线程数
keepAliveTime, 当活跃线程数大于核心线程数时, 空闲的多余线程最大存活时间
unit 存活时间的单位
workQueue 存放任务的队列
handler 超出线程范围和队列容量的任务的处理程序, 也叫拒绝策略.
3, 先看下线程池的实现原理
提交一个任务到线程池, 线程池的处理流程如下
判断核心线程池是否都在执行任务, 如果不是, 则创建新的线程执行任务
若核心线程都在执行任务, 判断工作队列满没满, 如果没满, 把任务提交给队列
若队列满了, 判断线程池里的线程是否都处于工作状态. 如果没有, 则创建一个新的工作线程来执行任务, 如果满了则交给拒绝策略处理
来源: http://www.bubuko.com/infodetail-2946536.html