文章目录
线程相关的概念
计算机程序运行的过程
计算机分为几种设备:
- 输入设备:键盘、鼠标
- 输出设备:显示器、耳机
- 存储设备:磁盘、内存、u盘
- 运算设备:cpu
进程和线程
进程:运行后的程序,是操作系统分配系统资源(内存空间、CPU)的最小单位
线程:每个进程由一个或多个线程组成,线程是CPU进行分配和调度的最小单位(分配时间片)
对比进程和线程:
1. 内存方面:
进程需要的资源更多(堆、方法区、本地方法区),线程更轻量级(栈、程序计数器)
线程共享所在进程的内存空间(堆、方法区、本地方法区)
-
创建和销毁以及上下文切换:
进程需要更多时间和资源,线程更快
- 相互通信方面:
进程之间的通信比较麻烦(RPC、网络),线程之间通信更容易(通过进程共享的内存空间)
并行和并发
一个CPU内核一个时间段只能运行一个线程的指令,因为CPU执行的速度特别快所以感觉多个程序同时运行
并发:一个CPU在多个线程间来回切换执行,不是真正同时执行
并行:多个CPU同时执行多个线程,是真正同时执行
同步和异步
程序指令执行过程分为:
同步:多个程序指令排队执行
执行有序,数据更加安全
异步:多个程序指令同时执行
效率更高,执行无序,数据可能会有问题
为什么要使用多线程
线程是程序指令的单独的执行路径,多线程同时执行,大大提高了程序的执行效率
应用场景:
- 多线程下载
- 游戏(图形绘制、游戏控制、网络通信。。)
- 互联网应用(服务器为每个用户单独开线程,相互不影响)
线程的实现
java实现的三种方法:
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口
继承Thread类
1) 定义类继承Thread类
2) 重写run方法
3) 创建线程对象,调用start方法
/**
* 自定义线程
*/
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"---->"+i);
}
}
public static void main(String[] args) {
//创建线程对象
MyThread thread1 = new MyThread();
//启动线程
thread1.start();
//主线程执行
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"---->"+i);
}
}
}
面试问题
1) 执行run和start有什么区别?
调用run是在主线程中同步执行的,调用start后才会启动新线程去执行
2) 调用两次start会怎么样?
会抛出异常IllegalThreadStateException,线程是一次性的,不允许执行两次
3) 多线程的执行是什么顺序?
上下文切换
多线程的执行是抢占式的,线程会去抢占CPU,抢到后执行自己的指令,执行过程中CPU可能被其它线程抢占,其它线程执行
上下文切换回原来线程时,如何执行从哪里开始执行?
每个线程有自己的程序计数器,保存当前线程执行的行数,切换回来后继续执行下面的行代码
实现Runnable接口
1) 定义类实现Runnable接口
2) 实现run方法
3) 创建Thread对象,传入Runnable对象,调用start
/**
* 自定线程 Runnable方式
*/
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
public static void main(String[] args) {
//创建Runnable对象 创建Thread对象
Thread thread1 = new Thread(new MyRunnable());
//启动线程
thread1.start();
//匿名内部类
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
}
});
thread2.start();
//lambda表达式
Thread thread3 = new Thread(()->{
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
}
});
thread3.start();
}
}
面试问题
1) 继承Thread类和实现Runnable两种方式的区别
1> Java是单继承的,继承Thread类就不能继承其它类,实现接口没有此限制
2> 继承Thread不强制要求重写run,实现Runnable强制要求
3> Runnable可以使用Lambda表达式,语法简介
推荐使用Runnable方式
实现Callable接口
前面两种方式都实现的run方法没有返回值,如果需要进行运算后返回值,就需要使用Callable接口
1) 实现Callable接口的call方法
2) 创建FutureTask对象传入Callable实现对象
3) 创建Thread线程传入FutureTask对象
4) 启动线程
5) 通过FutureTask的get方法获得返回值
/**
* 带返回值的线程对象
*/
public class MyCallable implements Callable<Long> {
@Override
public Long call() throws Exception {
long sum = 0;
for(int i = 0;i < 10000000;i++){
sum += i;
}
return sum;
}
public static void main(String[] args) {
//创建FutureTask对象,传入Callable对象
FutureTask<Long> futureTask = new FutureTask<>(new MyCallable());
//创建Thread对象
Thread thread = new Thread(futureTask);
//启动线程
thread.start();
//获得返回值
try {
Long value = futureTask.get();
System.out.println("运算结果是:" + value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
线程的生命周期
线程的生命周期(状态)分为:
- 新建
- 就绪/准备
- 运行
- 阻塞
- 死亡
线程的常用方法
常用方法:
- start() 启动线程
- stop() 停止线程
- setName(String) 设置名字
- getName() 获得名字
- sleep(long) 睡眠
- suspend() 挂起线程
- resume() 恢复线程
- yield() 放弃执行
- join() 合并线程
- setPriority(int) 设置线程优先级
- setDaemon(boolean) 设置后台线程
停止线程
- stop() 调用stop会停止线程,不会释放锁,可能导致死锁,禁用stop
- 等待run执行完
- 在run执行代码中加入条件,中途停止执行
线程的睡眠
Thread类的静态方法 sleep(毫秒数)
Thread.sleep(毫秒) 阻塞住当前线程,当时间结束后线程自动唤醒
面试题:wait和sleep的区别
- 调用对象不同: wait是锁对象调用,sleep是当前线程调用
- 唤醒机制不同: 线程进入wait后,要通过锁对象notify/notifyAll唤醒,sleep当时间结束自动唤醒
- 锁释放不同:线程进入wait后,会自动释放锁,线程sleep不会释放锁
线程的优先级
线程有优先级从低到高分为1~10,默认是5
线程优先级越高抢到CPU的几率越高
可以给执行更重要任务的线程设置更高的优先级
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
});
//设置优先级
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.setPriority(Thread.MIN_PRIORITY);
thread1.start();
thread2.start();
后台线程
后台线程也叫守护线程(精灵线程),后台线程的任务是为其它线程提供服务,当其它线程都死亡后,后台线程会自动死亡
setDaemon(true) 设置后台线程
应用场景:gc线程(垃圾收集器)就是典型的后台线程
public class DaemonDemo {
public static void main(String[] args) {
Thread daemon = new Thread(() -> {
for (int i = 0; ; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
daemon.setName("守护线程");
//设置守护线程
daemon.setDaemon(true);
daemon.start();
//被守护线程
for (int i = 0; i < 3; i++) {
new Thread(() -> {
for (int j = 0; j < 10; j++) {
System.out.println(Thread.currentThread().getName()+"--->"+j);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
合并线程
线程的执行是抢占式的,在线程内部可以合并其它线程,让其它线程的执行代码在当前线程前面执行,然后执行自己的指令
public class JoinDemo {
static Thread thread1 = null,thread2 =null ;
public static void main(String[] args) {
thread1 = new Thread(()->{
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
try {
// if(i == 5){
// thread2.join();
// }
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread2 = new Thread(()->{
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"执行了"+i);
try {
if(i == 5){
//合并线程1
thread1.join();
}
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread2.setName("帅小伙");
thread1.setName("老太太");
thread1.start();
thread2.start();
}
}