线程基础
进程与线程
进程
- 进程:是系统进行分配和管理资源的基本单位。
- 进程有自己的独立地址空间,每启动一个进程,系统就会为它分配地址空间,建立数据表来维护代码段、堆栈段和数据段,这种操作非常昂贵。
线程
- 线程:进程的一个执行单元,是进程内调度的实体、是CPU调度和分派的基本单位,是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。
- 线程是共享进程中的数据的,使用相同的地址空间,因此CPU切换一个线程的花费远比进程要小很多,同时创建一个线程的开销也比进程要小很多。
- 一个程序至少一个进程,一个进程至少一个线程。
- 线程之间的通信更方便,同一进程下的线程共享全局变量、静态变量等数据,而进程之间的通信需要以通信的方式进行。
- 多进程程序更健壮,进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响, 而线程只是一个进程中的不同执行路径。
- 线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,所以可能一个线程出现问题,进而导致整个程序出现问题。
进程的状态
- 创建状态:由进程申请一个空包PCB,并向PCB中填写用于控制和管理进程的信息,然后为该进程分配运行时所必须的资源。
- 就绪状态:指进程已处于准备好运行的状态,即进程已分配到除CPU以外的所有必要资源后,只要再获得CPU,便可立即执行。如果系统中有许多处于就绪状态的进程,将它们按照一定策略排成一个队列,称为就绪队列。
- 执行状态:指进程已获得CPU,其程序正在执行的状态。
- 阻塞状态:指正在执行的进程由于发生某事件(如I/O请求、申请缓冲区失败等)暂时无法继续执行的状态,即进程的执行收到阻塞。
- 终止状态:等待操作系统进行善后处理,最后将其PCB清零,并将PCB空间返还系统。
线程的状态
- 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
- 运行(RUNNABLE):处于可运行状态的线程正在JVM中执行,但它可能正在等待来自操作系统的其他资源,例如处理器。
- 阻塞(BLOCKED):线程阻塞于synchronized锁,等待获取synchronized锁的状态。
- 等待(WAITING):Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
- 超时等待(TIME_WAITING):Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil,该状态不同于WAITING,它可以在指定的时间内自行返回。
- 终止(TERMINATED):表示该线程已经执行完毕。
创建线程的方式
1.继承Thread,并重写父类的run方法
public class MyThread extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.setName("线程demo");
myThread.start();
}
}
2.实现Runable接口,并实现run方法
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.setName("runnable demo thread");
thread.start();
//thread.run();
}
}
多选择第二种,java只允许单继承,增加程序的健壮性,代码可以共享,代码和数据独立。
- 调用thread.run();时,不会启动一个线程处理,依旧在主程序里,输出的是 main,是相应当前的线程的名字。
3.实现Callable接口
/**
* 实现callable接口
*/
public class MyCallable implements Callable {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum+=1;
}
return sum;
}
public static void main(String[] args) {
Callable<Integer> callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask(callable);
Thread thread = new Thread(futureTask);
thread.setName("callableThread");
thread.start();
//接收线程运算后的结果
try {
Integer sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
继承类与实现类的区别
- 线程类继承自Thread 则不能再继承其他类,而Runnable/Callable接口可以。
- 线程类继承自Thread 对于Runnable/Callable来说,使用线程类内部的方法方便一些。
- 实现Runnable接口的线程类的多个线程可以更加方便的访问同一变量,而Thread类则需要内部类进行代替。
Runnable和Callable的区别:
- Runnable规定的方法是run(),Callable规定的方法是call()。
- Runnable的任务是不能返回值的,Callable的任务执行后可返回值。
- run()方法不能抛出异常,call()方法可抛出异常。
- Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。
- 运行Callable任务可拿到一个Future对象,Future表示异步计算的结果。提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象了解任务的执行情况,可取消任务的执行,还可以获取任务执行的结果。
4.使用匿名内部类
/**
* 匿名内部类的方式
*/
public class MyThread {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
thread.start();
}
}
5.Lambda表达式方法创建
public class LambdaThread {
public static void main(String[] args) {
new Thread(()->{
System.out.println(Thread.currentThread().getName());
}).start();
}
}
6.通过线程池创建
/**
* 通过线程池创建线程
* 创建之后程序不会停止
*/
public class ThreadPool {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.execute(()->{
System.out.println(Thread.currentThread().getName());
});
//还是实现的Runnable
//executorService.execute(new Runnable() {
// @Override
// public void run() {
// //其他操作
// }
// });
}
}
- 4,5,6还是实现的Runnable接口,不过是换了一种形式。