线程的实现
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两种方式的区别
- Java是单继承的,继承
Thread
类就不能继承其它类,实现接口没有此限制- 继承
Thread
不强制要求重写run
,实现Runnable
强制要求重写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();
}
}
}
线程的生命周期
线程的生命周期(状态)分为:
- 新建
- 就绪/准备
- 运行
- 阻塞
- 死亡
如下图所示: