此篇是本人在准备java开发岗位时准备的一些关于多线程的知识点和一些面试需要特别注意的地方,还有诸多面试知识点在主页,欢迎大家查看,互相交流学习~~后续还会有续集
线程状态:创建、就绪、运行、阻塞、死亡
方法 | 作用 | 区别 |
---|---|---|
start | 启动线程,由虚拟机自动调度执行run()方法 | 线程处于就绪状态 |
run | 线程逻辑代码块处理,JVM调度执行 | 线程处于运行状态 |
sleep | 让当前正在执行的线程休眠(暂停执行) | 不释放锁 |
wait | 使得当前线程等待 | 释放同步锁 |
notify | 唤醒在此对象监视器上等待的单个线程 | 唤醒单个线程 |
notifyAll | 唤醒在此对象监视器上等待的所有线程 | 唤醒多个线程 |
yiled | 停止当前线程,让同等优先权的线程运行 | 用Thread类调用 |
join | 使当前线程停下来等待,直至另一个调用join方法的线程终止 | 用线程对象调用 |
yield () 执行后线程直接进入就绪状态,马上释放了cpu的执行权,但是依然保留了cpu的执行资格,所以有可能cpu下次进行线程调度还会让这个线程获取到执行权继续执行
join () 执行后线程进入阻塞状态,例如在线程B中调用线程A的join (),那线程B会进入到阻塞队列,直到线程A结束或中断线程
1.根本区别:进程是操作系统进行资源分配的最小单元,线程是操作系统进行运算调度的最小单元。
2.从属关系不同:进程中包含了线程,线程属于进程。
3.开销不同:进程的创建、销毁和切换的开销都远大于线程。
4.拥有资源不同:每个进程有自己的内存和资源,一个进程中的线程会共享这些内存和资源。
5.控制和影响能力不同:一个进程崩溃后,在保护模式下不会对其他进程产生影响,但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
6.CPU利用率不同:进程的CPU利用率较低,因为上下文切换开销较大,而线程的CPU的利用率较高,上下文的切换速度快。
7.操纵者不同:进程的操纵者一般是操作系统,线程的操纵者一般是编程人员。
继承类Thread是支持多线程的功能类,只要创建一个子类就可以实现多线程的支持。
所有的java程序的起点是main方法,所以线程一定有自己的起点,那这个起点就是run方法;因为多线程的每个主体类之中必须重写Thread的run方法。
这个run方法没有返回值,那就说明线程一旦开始就一直执行不能返回内容。
多线程启动的唯一方法是调用Thread的start方法,如果调用的是run方法就是普通run方法的调用(调用此方法执行的是run方法体)。
总结:使用Thread类的start方法不仅仅启动多线程的执行代码,还要从不同操作系统中分配资源。
步骤:
继承Thread类(java不支持多继承)
public class ExtendsThread extends Thread {
@Override
public void run() {System.out.println('用Thread类实现线程');}
}
Java具有单继承局限,所有的Java程序针对类的继承都应该是回避,那么线程也一样,为了解决单继承的限制,因此才有Runnable接口。
使用方法:让一个类实现Runnable接口即可,并且也需要覆写run()方法。
疑问:但是此接口只有run方法,没有start方法,怎么启动多线程呢?
不管任何情况下,如果要想启动多线程一定要依靠Thread类完成,在Thread类中有参数是Runnable参数的构造方法:
Thread(Runnable target) 接收的是Runnable接口
可以创建一个参数是Runnable实现类的Thread类,调用start方法启动。
总结:实现Runnable接口来写多线程的业务类,用Thread来启动多线程。
实现 Runnable 接口(优先使用)
public class RunnableThread implements Runnable {
@Override
public void run() {System.out.println('用实现Runnable接口实现线程');}
}
实现Callable接口(有返回值可抛出异常)
步骤:
//class CallableTask implements Callable<Integer> {
//@Override
//public Integer call() throws Exception { return new Random().nextInt();}
//}
@Override
public Object call() throws Exception {
System.out.println("CallableImpl");
return "我是Call方法的返回值";
}
public static void main(String[] args) {
CallableImpl callable=new CallableImpl();
FutureTask<Object> futureTask=new FutureTask<>(callable);
Thread thread=new Thread(futureTask);
需要注意一件事:
FutureTask类中的get方法获取返回值只能执行一次
而且,如果使用了这个方法但是线程还没有运行到可以返回的那行代码,那么就会一直阻塞
比如如果我在这里执行了如下代码:
Object result=futureTask.get();
那么就永远阻塞了
当然,我更想说的是,如果你使用的是这种方法创建线程并且需要返回值的话,里面就别写死循环
否则就是死锁在召唤
thread.start();
try {
Object result=futureTask.get();
System.out.println(result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
(底层都是实现run方法)
static class DefaultThreadFactory implements ThreadFactory {
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "pool-" + poolNumber.getAndIncrement() +"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
if (t.isDaemon()) t.setDaemon(false); //是否守护线程
if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); //线程优先级
return t;
}
}
优点:通过复用已创建的线程,降低资源损耗、线程可以直接处理队列中的任务加快响应速度、同时便于统一监控和管理。
/**
* 线程池构造函数7大参数
*/
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,
RejectedExecutionHandler handler) {}
参数介绍:
参数 | 作用 |
---|---|
corePoolSize | 核心线程池大小,核心线程数,也就是正常情况下创建工作的线程数,这些线程创建后并不会消除,而是一种常驻线程 |
maximumPoolSize | 最大线程池大小,最大线程数,它与核心线程数相对应,表示最大允许被创建的线程数,比如当前任务较多,将核心线程数都用完了,还无法满足需求时,此时就会创建新的线程,但是线程池内线程总数不会超过最大线程数 |
keepAliveTime | 线程池中超过 corePoolSize 数目的空闲线程最大存活时间;超出核心线程数之外的线程的空闲存活时间,也就是核心线程不会消除,但是超出核心线程数的部分线程如果空闲一定的时间则会被消除,我们可以通过 setKeepA7iveTime来设置空闲时间 |
TimeUnit | keepAliveTime 时间单位 |
workQueue | 阻塞任务队列,用来存放待执行的任务,假设我们现在核心线程都已被使用,还有任务进来则全部放入队列,直到整个队列被放满但任务还再持续进入则会开始创建新的线程 |
threadFactory | 新建线程工厂,是一个线程工厂,用来生产线程执行任务。我们可以选择使用默认的创建工厂,产生的线程都在同一个组内,拥有相同的优先级,且都不是守护线程。当然我们也可以选择自定义线程工厂,一般我们会根据业务来制定不同的线程工厂 |
RejectedExecutionHandler | 拒绝策略。当提交任务数超过 maxmumPoolSize+workQueue 之和时,任务会交给RejectedExecutionHandler 来处理,任务拒绝策略,有两种情况,第一种是当我们调用shutdown 等方法关闭线程池后,这时候即使线程池内部还有没执行完的任务正在执行,但是由于线程池已经关闭,我们再继续想线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数,线程池已经没有能力继续处理新提交的任务时,这是也就拒绝 |
拒绝策略:
线程池中的线程已经用完了,无法继续为新任务服务,同时,等待队列也已经排满了,再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。
JDK 内置的拒绝策略如下:
AbortPolicy: 直接抛出异常,阻止系统正常运行。可以根据业务逻辑选择重试或者放弃提交等策略。
CallerRunsPolicy : 只要线程池未关闭,该策略直接在调用者线程中,运行当前被丢弃的任务。
不会造成任务丢失,同时减缓提交任务的速度,给执行任务缓冲时间。
DiscardOldestPolicy : 丢弃最老的一个请求,也就是即将被执行的任务,并尝试再次提交当前任务。
DiscardPolicy : 该策略默默地丢弃无法处理的任务,不予任何处理。如果允许任务丢失,这是最好的一种方案。
因为以上方式都存在弊端:
FixedThreadPool 和 SingleThreadExecutor : 允许请求的队列⻓度为 Integer.MAX_VALUE,会导致OOM。 CachedThreadPool 和 ScheduledThreadPool : 允许创建的线程数量为 Integer.MAX_VALUE,会导致OOM。
手动创建的线程池底层使用的是ArrayBlockingQueue可以防止OOM。
CPU 密集的意思是该任务需要大量的运算,而没有阻塞,CPU 一直全速运行。
CPU 密集型任务尽可能的少的线程数量,一般为 CPU 核数 + 1 个线程的线程池。
由于 IO 密集型任务线程并不是一直在执行任务,可以多分配一点线程数,如 CPU * 2
也可以使用公式:CPU 核心数 *(1+平均等待时间/平均工作时间)。
优点:通过复用已创建的线程,降低资源损耗、线程可以直接处理队列中的任务加快响应速度、同时便于统一监控和管理。
1.降低资源消耗
线程的创建和销毁会造成一定的时间和空间上的消耗,线程池可以让我们重复利用已创建的线程。
2.提高响应速度
线程池已为我们创建好了线程,当任务到达时可以不需要等到线程创建就能立即执行。
3.提高线程的可管理性
线程是稀缺资源,不可能无限的创建,使用线程池可以进行统一分配、调优和监控。
4.提供更多更强大的功能
线程池具备可拓展性,允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor,就允许任务延期执行或定期执行。
1、一般的队列只能保证作为一个有限长度的缓冲区,如果超出了缓冲长度,就无法保留当前的任务了,阻塞队列通过阻塞可以保留住当前想要继续入队的任务。
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程,使得线程进入wait状态,释放cpu资源。
阻塞队列自带阻塞和唤醒的功能,不需要额外处理,无任务执行时,线程池利用阻塞队列的take方法挂起,从而维持核心线程的存活、不至于一直占用cpu资源
为什么是先添加队列而不是先创建最大线程?
在创建新线程的时候,是要获取全局锁的,这个时候其它的就得阻塞,影响了整体效率。
线程池将线程和任务进行解耦,线程是线程,任务是任务,摆脱了之前通过Thread创建线程时的一个线程必须对应一个任务的限制。
在线程池中,同一个线程可以从阻塞队列中不断获取新任务来执行,其核心原理在于线程池对Thread进行了封装,并不是每次执行任务都会调用Thread.start()来创建新线程,而是让每个线程去执行一个"循环任务",在这个"循环任务"中不停检查是否有任务需要被执行,如果有则直接执行,也就是调用任务中的run方法,将run方法当成一个普通的方法执行,通过这种方式只使用固定的线程就将所有任务的run方法串联起来。