- 前言
1、线程不可单独存在,必须存在于进程中(进程是操作系统中打开一个应用程序的映射)
2、推荐使用多线程来实现程序的并发设计,线程间的切换与调度对资源的消耗要远远小于进程
3、CPU的资源分配采用了时间片轮转策略【CPU会为每一个线程动态的分配一个时间片,每个线程在各自的时间片内占用CPU执行相关操作,当时间片用完后便进入就绪状态等待CPU再次为其分配时间片】,因为CPU执行线程间的切换很快,所以用户感觉多个线程是在同时执行(即多线程并发)
线程的分类
- 用户线程:用户自定义的线程
- 守护线程:服务于用户线程,直到相关用户线程都执行完毕后jvm进程退出,此时守护线程才会跟着一起退出(JVM的垃圾回收器本质就是一个守护线程)
线程的创建
- Runnable 接口
class DemoRunnable implements Runnable {
@Override
public void run() {
System.out.println(MessageFormat.format("线程名称:{0} 正在执行", Thread.currentThread().getName()));
}
}
public class Demo {
public static void main(String[] args) {
Thread thread = new Thread(new DemoRunnable(), "自定义线程A");
thread.start();
}
}
- Callable 接口(有返回值)
class DemoCallable implements Callable<String> {
@Override
public String call() throws Exception {
String res = "运行成功";
System.out.println(MessageFormat.format("线程名称:{0} 正在执行, 运行结果位:{1}", Thread.currentThread().getName(), res));
return res;
}
}
public class Demo {
public static void main(String[] args) {
FutureTask<String> futureTask = new FutureTask<String>(new DemoCallable());
Thread thread = new Thread(futureTask, "自定义线程A");
thread.start();
// TODO 每秒轮询一次,检查当前线程是否执行完毕
while (!futureTask.isDone()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
// TODO 获取当前线程中的返回值(get会阻塞当前线程)
System.out.println("返回值:" + futureTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
线程的生命周期
调用start()方法后会进入就绪状态,等待CPU为其分配时间片,获取时间片后才会调用run()方法、call()方法进行相关操作(注意直接调用是不生效的),执行结束后线程将会被销毁
- sleep
在休眠时间内,不释放占用的资源,且会阻塞其他线程 - wait
释放占用的资源,在指定时间后会重新进入就绪状态。如果没有指定时间,则需要通过其他线程来唤醒 - yield
释放占用的资源并进入就绪状态 - join
在执行过程中,遇到其它线程join时,会等待该线程执行成功后才会继续执行
线程池(有效避免重复创建、销毁线程所带来的不必要开销)
Exectutor 接口 – ExecutorService 接口 – ThreadPoolExecutor 类
- ThreadPoolExecutor
corePoolSize:初始线程数量
workQueue:当线程并发数量超过初始线程数量时,待处理的线程存入阻塞队列进行管理
maximumPoolSize:阻塞队列中的线程数量达到最大时,可继续创建线程的最大数量
handler:拒绝策略(当最大线程数量都达到最大时,处理新提交任务的策略)
keepAliveTime:空闲线程的存活时间(unit:时间单位)
public static void main(String[] args) {
ExecutorService executorService = new ThreadPoolExecutor(
2,
10,
30, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10),
new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 2; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(MessageFormat.format("线程名称:{0}", Thread.currentThread().getName()));
}
});
}
// 关闭线程
executorService.shutdown();
}
线程名称:pool-1-thread-1
线程名称:pool-1-thread-2
public static void main(String[] args) {
ExecutorService executorService = new ThreadPoolExecutor(
2,
10,
30, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10),
new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 0; i < 2; i++) {
Future<Integer> future = executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return 1;
}
});
// TODO 每秒轮询当前线程的状态
while (!future.isDone()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// TODO 当前线程执行成功后从Future中取出返回值
try {
System.out.println(future.get());
} catch (Exception e) {
e.printStackTrace();
}
}
// 关闭线程
executorService.shutdown();
}
注意:Java8引入的CompletableFuture类实现了CompletionStage和Future接口,提供了函数式异步编程的能力,通过操作系统回调函数的方式处理异步结果,相比于Future它不会造成主线程的阻塞现象