本文详细介绍了Java多线程的基础知识，包括进程与线程的区别、并行与并发的概念、线程的生命周期和状态。还探讨了守护线程、上下文切换以及线程创建的两种方式——继承Thread类和实现Runnable接口。文章特别强调了线程池的使用，解析了四种常见线程池的用法和线程池的工作策略，如任务队列、丢弃策略和线程工厂的配置。
Java并发基础
何为进程
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
何为线程
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
Java 程序天生就是多线程程序，我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程，代码如下。
public class TestSolution {
public static void main(String[] args) {
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
// 遍历线程信息，仅打印线程 ID 和线程名称信息
for (ThreadInfo threadInfo : threadInfos) {
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
}
}
}
运行结果
[5] Attach Listener //添加事件
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //调用对象 finalize 方法的线程
[2] Reference Handler //清除 reference 线程
[1] main //main 线程,程序入口
从上面的输出内容可以看出：一个 Java 程序的运行是 main 线程和多个其他线程同时运行。
并行和并发
并发：同一个时间段，多个任务同时执行（单位时间可能切换执行）
并行：单位时间，多个任务同时执行
Java线程声明周期和状态
守护线程和用户线程
- 用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程
- 守护线程：运行在后台，为其他前台线程服务.也可以说守护线程是 JVM 中非守护线程的 “佣人”。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作.
比较明显的区别之一是用户线程结束，JVM 退出，不管这个时候有没有守护线程运行。而守护线程不会影响 JVM 的退出。
上下文切换
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。
概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换会这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。
上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
线程创建和执行
继承Thread类
public class MyThead extends Thread{
private int count = 5;
private String name;
public MyThead(String name) {
this.name = name;
}
public void run() {
for(int i = 0; i < 5; i ++) {
System.out.println("Thead: " + name + " count = " + count --);
}
try {
sleep((int)Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MyThead thread1 = new MyThead("A");
MyThead thread2 = new MyThead("B");
thread1.start();
thread2.start();
}
}
运行结果
实现Runnable接口
public class Mythread2 implements Runnable{
private int count = 15;
@Override
public void run() {
for(int i = 0; i < 5; i ++) {
System.out.println(Thread.currentThread().getName() + " count = " + count --);
try {
Thread.sleep((int)Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Mythread2 mythread2 = new Mythread2();
new Thread(mythread2, "A").start();
new Thread(mythread2, "B").start();
new Thread(mythread2, "C").start();
}
}
结果
继承Thread和实现Runnable接口的区别
从上面两个代码可以看到：
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
线程池
四种常见的线程池
1. newCachedThreadPool();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}
2. newFixedThreadPool(5);
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);//nThread
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
3. newScheduledThreadPool(5);
ScheduledExecutorService scheduledThreadPool =Executors.newScheduledThreadPool(5);//corePoolSize
package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
}
}
父类是ScheduledExecutorService，另外注意这个地方使用schedule方法而不是execute方法
4. newSingleThreadExecutor()
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
结果会依次输出，相当于顺序执行
线程池执行策略
execute执行流程如下：
- 如果线程数小于核心线程数，那么添加工作线程执行
- 否则加入到阻塞队列
- 如果阻塞队列满了，并且小于最大线程数，那么添加工作线程执行
- 大于最大线程数则采用对应的拒绝策略处理
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核心池大小，既然如前原理部分所述。需要注意的是在初创建线程池时线程不会立即启动，直到有任务提交才开始启动线程并逐渐时线程数目达到corePoolSize。若想一开始就创建所有核心线程需调用prestartAllCoreThreads方法。
-
maximumPoolSize-池中允许的最大线程数。需要注意的是当核心线程满且阻塞队列也满时才会判断当前线程数是否小于最大线程数，并决定是否创建新线程。
-
keepAliveTime - 当线程数大于核心时，多于的空闲线程最多存活时间
-
unit - keepAliveTime 参数的时间单位。
-
workQueue - 当线程数目超过核心线程数时用于保存任务的队列。主要有3种类型的BlockingQueue可供选择：无界队列，有界队列和同步移交。将在下文中详细阐述。从参数中可以看到，此队列仅保存实现Runnable接口的任务。 别看这个参数位置很靠后，但是真的很重要，因为楼主的坑就因这个参数而起，这些细节有必要仔细了解清楚。
-
threadFactory - 执行程序创建新线程时使用的工厂。
-
handler - 阻塞队列已满且线程数达到最大值时所采取的饱和策略。java默认提供了4种饱和策略的实现方式：中止、抛弃、抛弃最旧的、调用者运行。
任务队列
主要有3种类型的BlockingQueue：
无界队列
队列大小无限制，常用的为无界的LinkedBlockingQueue，使用该队列做为阻塞队列时要尤其当心，当任务耗时较长时可能会导致大量新任务在队列中堆积最终导致OOM。阅读代码发现，Executors.newFixedThreadPool 采用就是 LinkedBlockingQueue，而当QPS很高，发送数据很大，大量的任务被添加到这个无界LinkedBlockingQueue 中，导致cpu和内存飙升服务器挂掉。
有界队列
常用的有两类，一类是遵循FIFO原则的队列如ArrayBlockingQueue与有界的LinkedBlockingQueue，另一类是优先级队列如PriorityBlockingQueue。PriorityBlockingQueue中的优先级由任务的Comparator决定。
使用有界队列时队列大小需和线程池大小互相配合，线程池较小有界队列较大时可减少内存消耗，降低cpu使用率和上下文切换，但是可能会限制系统吞吐量。有界队列可能使任务丢失
同步移交队列
如果不希望任务在队列中等待而是希望将任务直接移交给工作线程，可使用SynchronousQueue作为等待队列。==SynchronousQueue不是一个真正的队列，而是一种线程之间移交的机制。要将一个元素放入SynchronousQueue中，必须有另一个线程正在等待接收这个元素。==只有在使用无界线程池或者有饱和策略时才建议使用该队列。
Executors.newCachedThreadPool()就是使用SynchronousQueue来保证每一个任务过来都会有线程处理
丢弃策略
- new ThreadPoolExecutor.AbortPolicy() 丢弃抛异常
- new ThreadPoolExecutor.DiscardPolicy() 不做任何处理直接丢弃
- new ThreadPoolExecutor.DiscardOldestPolicy()先将阻塞队列中的头元素出队抛弃，再尝试提交任务。
- new ThreadPoolExecutor.CallerRunsPolicy()既不抛弃任务也不抛出异常，直接运行任务的run方法，换言之将任务回退给调用者来直接运行。使用该策略时线程池饱和后将由调用线程池的主线程自己来执行任务，因此在执行任务的这段时间里主线程无法再提交新任务，从而使线程池中工作线程有时间将正在处理的任务处理完成。
- 自定义丢弃策略，实现RejectedExecutionHandler接口
public class AbortPolicyWithReport implements RejectedExecutionHandler {
protected static final Logger logger = LoggerFactory
.getLogger(AbortPolicyWithReport.class);
private final String threadName;
public AbortPolicyWithReport(String threadName) {
this.threadName = threadName;
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
String msg = String
.format("Thread pool is EXHAUSTED!"
+ " Thread Name: %s, Pool Size: %d (active: %d, core: %d, max: %d, largest: %d), Task: %d (completed: %d), Executor status:(isShutdown:%s, isTerminated:%s, isTerminating:%s)!",
threadName, e.getPoolSize(), e.getActiveCount(),
e.getCorePoolSize(), e.getMaximumPoolSize(),
e.getLargestPoolSize(), e.getTaskCount(),
e.getCompletedTaskCount(), e.isShutdown(),
e.isTerminated(), e.isTerminating());
logger.warn(msg);
throw new RejectedExecutionException(msg);
}
}
新线程工厂
实现ThreadFactory接口，返回一个Thread
public class CommonThreadFactory implements ThreadFactory {
private AtomicInteger threadNum = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setName("common-thread-pool-" + threadNum.incrementAndGet());
return t;
}
}
实践
线程池作为一个静态的域，这样调用这个方法的时候，就可以公用这个线程池了。
private static ThreadPoolExecutor threadPoolExecutor = getNewThreadPoolExecutor();
public static ThreadPoolExecutor getNewThreadPoolExecutor() {
int queueSize = 30;
//30秒
int keepalive = 30;
return new ThreadPoolExecutor(10, 50, keepalive, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(queueSize), new CommonThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy());
}
public static void test(user) {
threadPoolExecutor.execute(new Access(user));
}
扫一扫
107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
