多线程相关的问题
1.什么是进程?
正在执行的程序
2.什么是线程?
进程的子单位,一个能够完成独立功能的执行路径
3.为什么需要开启多线程?
- 当执行某些耗时操作的任务的时候需要开启多线程,防止线程阻塞
- 能够让两个任务看起来像是在同时执行
- 提高CPU的使用率,进而提高进程和内存的使用率
4.为什么开启多线程会同时执行?
因为CPU切换执行的速度太快了,肉眼无法差距
5.开启多线程是不是越多越好,提高了效率还是降低了效率?
不是,线程越多,效率越慢,但是太少,浪费CPU资源,所以,合理利用CPU
6.并发和并行的区别
- 并发 --> 在同一个时间段下同时执行多个线程,看起来像同时执行
- 并行 --> 在同一个时间刻度下(不能够在分割的时间单位)执行多个线程,本质就上就是同时执行
CPU在某一个最小的时间刻度单位下,执行的是一个进程的一个线程的一个不可再分割的原子性语句
线程开启方式
Java提供了三种创建线程方法：
1.继承Thread类的方式
2.实现Runnable的方式
3.通过 Callable 和 Future 创建线程。
方式一：继承Thread类
1.自定义类MyThread继承Thread类。3
2.MyThread类里面重写run()方法。
3.创建线程对象。
4.启动线程。
注意：
1、启动线程使用的是start()方法而不是run()方法
2、线程能不能多次启动线程对象调用 run方法和调用start方法区别？
- 线程对象调用run方法不开启线程。仅是对象调用方法。
- 线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行
代码演示使用方式一开启线程
// 方式二：实现Runnable接口
class CalculateRunnable implements Runnable {
private int m;
private int n;
public CalculateRunnable(int m, int n) {
super();
this.m = m;
this.n = n;
}
public CalculateRunnable() {
super();
}
@Override
public void run() {
int sum = 0;
for (int i = m; i <= n; i++) {
sum += i;
System.out.println("CalculateRunnable子线程: " + i);
}
System.out.println(m + "~" + n + "的和: " + sum);
}
}
方式二：实现Runnable接口
1.自定义类MyRunnable实现Runnable接口
2.重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象，并把步骤3创建的对象作为构造参数传递
5.启动线程实现接口方式的好处
可以避免由于Java单继承带来的局限性。
适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。代码演示方式二开启线程
// 方式一：继承Thread类
class CopyThread extends Thread {
private File srcFile;
private File descFile;
public CopyThread() {
super();
}
public CopyThread(File srcFile, File descFile) {
super();
this.srcFile = srcFile;
this.descFile = descFile;
}
@Override
public void run() {
// main方法怎么写,这里就怎么写
copy(srcFile, descFile);
}
public void copy(File srcFile, File descFile) {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(descFile))){
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
bos.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
主方法调用
public static void main(String[] args) {
CopyThread ct = new CopyThread(new File("Test.java"), new File("Test.txt"));
CalculateRunnable cr = new CalculateRunnable(1, 200);
Thread t = new Thread(cr);
ct.start();
t.start();
for (int i = 0; i < 100; i++) {
System.out.println("main线程: " + i);
}
}
方式三: Callable 和 Future 创建线程。
- 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
- 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
- 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
- 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
继承Thread和实现Runnable的方式的特点:
1.没有返回结果
2.没有异常
Callable和Runnable的区别:
1.Runnable无返回值,没有异常抛出的
2.Callable可以在启动线程中获取返回值, 以及接受子线程的异常
线程间的数据传递:线程通信
A线程中开启了B线程
A --> B 通过构造方法
B --> A 通过Callable方式
public class CallableDemo{
public static void main(String[] args) {
FutureTask<Integer> task = new FutureTask<>(new CalculateCallable(0,100));
Thread t = new Thread(task);
t.start();
try {
Integer i = task.get();
System.out.println("计算结果: " + i);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("程序结束");
}
}
class CalculateCallable implements Callable<Integer> {
private int m;
private int n;
public CalculateCallable() {
super();
}
public CalculateCallable(int m, int n) {
super();
this.m = m;
this.n = n;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = m; i <= n; i++) {
System.out.println("子线程: " + i);
sum += i;
throw new NullPointerException("空指针异常!");
}
return sum;
}
}