线程、线程池

 

线程和多线程

线程

线程是进程的一个实体,是 CPU 调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程

与同属一个进程的其他的线程共享进程所拥有的全部资源。

多线程

多线程指在单个程序中可以同时运行多个不同的线程执行不同的任务。

线程的生命周期

线程生命周期

join()

线程A里运行了线程B.join(),则B线程插队进来,A线程阻塞到B执行完毕

wait()和sleep()

sleep()引起当前执行的线程进入暂时中断状态,也即睡眠状态。但是依然持有monitor对象。在中断完成之后,自动进入唤醒状态从而继续执行代码。

wait()是属于Object类的方法,在线程的运行过程中,调用该线程持有monitor对象的wait()方法时,该线程首先会进入等待状态,并将自己持有的monitor对象释放,如果一个线程正处于等待状态时,那么唤醒它的办法就是开启一个新的线程,通过notify()或者notifyAll()的方式去唤醒。当然,需要注意的一点就是,必须是同一个monitor对象。

notify()和notifyAll()

二者都是Object的方法

notify()

(1)当一个线程处于wait()状态时,也即等待它之前所持有的object’s monitor被释放,通过notify()方法可以让该线程重新处于活动状态,从而去抢夺object’s monitor,唤醒该线程。

(2)如果多个线程同时处于等待状态,那么调用notify()方法只能随机唤醒一个线程。

(3)在同一时间内,只有一个线程能够获得object’s monitor,执行完毕之后,则再将其释放供其它线程抢占。

notifyAll()

(1)notifyAll()只会唤醒那些等待抢占指定object’s monitor的线程,其他线程则不会被唤醒。

(2)notifyAll()只会一个一个的唤醒,而并非统一唤醒。因为在同一时间内,只有一个线程能够持有object’s monitor

(3)notifyAll()只是随机的唤醒线程,并非有序唤醒。

线程的实现方式

Thread、Runnable、Callable

实现 Runnable 接口相比继承 Thread 类有如下优势

1)可以避免由于 Java 的单继承特性而带来的局限

2)增强程序的健壮性,代码能够被多个线程共享,代码与数据是独立的

3)线程池只能放入实现 Runable 或 Callable 类线程,不能直接放入继承 Thread 的类

实现 Runnable 接口和实现 Callable 接口的区别

1)Runnable 是自从 java1.1 就有了,而 Callable 是 1.5 之后才加上去的

2)实现 Callable 接口的任务线程能返回执行结果,而实现 Runnable 接口的任务线程不能返回结果

3)Callable 接口的 call()方法允许抛出异常,而 Runnable 接口的 run()方法的异常只能在内部消化,不能继续上抛

4)加入线程池运行,Runnable 使用 ExecutorService 的 execute 方法,Callable 使用 submit 方法

注:Callable 接口支持返回执行结果,此时需要调用 FutureTask.get()方法实现,此方法会阻塞主线程直到获取返回结果,当不调用此方法时,主线程不会阻塞

线程池体系

线程池体系

Executor接口

名称:java.util.concurrent.Executor “执行者”接口,只提供了一个方法:

方法:java.util.concurrent.Executor#execute 执行接口

ExecutorService接口

名称:java.util.concurrent.ExecutorService 继承了Executor,在其上做了一些shutdown()、submit()的扩展,可以说是真正的线程池接口

方法:java.util.concurrent.ExecutorService#submit(java.lang.Runnable, T) 提交一个有返回值的任务,并返回一个Future代表等待的任务执行的结果,等到任务成功执行,Future#get()方法会返回任务执行的结果

AbstractExecutorService抽象类

名称:java.util.concurrent.AbstractExecutorService 实现了ExecutorService接口中的大部分方法;

方法:java.util.concurrent.AbstractExecutorService#submit(java.util.concurrent.Callable) 把执行和提交接口进行合并 区别:有返回值和无返回值

ThreadPoolExecutor类

名称:java.util.concurrent.ThreadPoolExecutor 继承了AbstractExecutorService,是线程池的具体实现;

方法:java.util.concurrent.ThreadPoolExecutor#execute 调用 addwork( offer>task 放队列)Run 方 法 调 用runwork 方 法getTask(从队列拿数据)

ScheduledExecutorService接口

名称:java.util.concurrent.ScheduledExecutorService 继承了ExecutorService接口,提供了带”周期执行”功能ExecutorService

方法:schedule、scheduleAtFixedRate、scheduleWithFixedDelay 定义方法接口

ScheduledThreadPoolExecutor类

名称:java.util.concurrent.ScheduledThreadPoolExecutor 既继承了TheadPoolExecutor线程池,也实现了ScheduledExecutorService接口,是带”周期执行”功能的线程池;

方法:java.util.concurrent.ScheduledThreadPoolExecutor#delayedExecute 具体实现 add>task>addWork

Executors

Executors是线程池的静态工厂,其提供了快捷创建线程池的静态方法。

线程池需要知道什么

三大方法、七大参数、拒绝策略、优化配置

三大方法

1、public static ExecutorService newFiexedThreadPool(int Threads) 创建固定数目线程的线程池。
2、public static ExecutorService newCachedThreadPool() 创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果没有可用的线程,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
3、public static ExecutorService newSingleThreadExecutor() 创建一个单线程化的Executor。

七大参数

分析三大方法的源码

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            60L, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>()));
}

ThreadPoolExecutor 源码

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

corePoolSize:线程池中核心线程数。核心线程会一直存活,即使没有任务需要执行,当线程数小于核心线程数时,即使有线程空闲,线程池也会优先创建新线程处理

maximumPoolSize:池中允许的最大线程数。当线程数>=corePoolSize,且任务队列已满时。线程池会创建新线程来处理任务;当线程数=maxPoolSize,且任务队列已满时,线程池会拒绝处理任务

keepAliveTime:线程池中的空闲线程所能持续的最长时间。当线程空闲时间达到keepAliveTime时,线程会退出,直到线程数量=corePoolSize

unit:持续时间的单位。

workQueue:任务执行前保存任务的队列。当核心线程数达到最大时,新任务会放在队列中排队等待执行

threadFactory:线程工厂,不用修改,用来创建线程

handler: 拒绝策略。1. AbortPolicy (默认的:队列满了,就丢弃任务抛出异常!)2. CallerRunsPolicy(哪来的回哪去? 哪个方法叫你来的,你就去哪里处理)3. DiscardOldestPolicy (尝试将最早进入队列的人任务删除,尝试加入队列) 4. DiscardPolicy (队列满了任务也会丢弃,不抛出异常)

史上最清晰易懂例子解释各个参数

七大参数

流程

当线程数小于核心线程数时,创建线程。

当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。

当线程数大于等于核心线程数,且任务队列已满,若线程数小于最大线程数,创建线程,若线程数等于最大线程数,抛出异常,拒绝任务

流程

当向线程池中提交一个任务,线程池会如何处理该任务

https://www.cnblogs.com/trust-freedom/p/6681948.html

execute() 提交任务

addWorker() 添加work线程

runWorker() 执行线程

getTask() 获取任务

processWorkerExit() worker线程退出


线程池用何种方式创建,最大参数如何设置

阿里巴巴开发手册规定如下

开发规约

合理创建线程数量

CPU 密集型:设置为 N+1,(N=cpu核心数: Runtime.getRuntime().availableProcessors()) CPU 密集型任务使得 CPU 使用率很高,若开过多的线程数,只能增加上下文切换的次数

IO 密集型:设置为 2N+1,IO密集型任务 CPU 使用率并不高,因此可以让 CPU 在等待 IO 的时候去处理别的任务,充分利用 CPU 时间

结论 线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。