最近回顾复习一下线程这一部分知识,这一块怎么也搞不明白(也不算搞不明白,不知道怎么使用),所以写下来,以便以后观看。
线程的四种创建方式
1、继承Thread类(重要)
创建一个类通过extends关键字继承Thread类,然后在主方法中重写Thread类中的run()方法,创建子类对象,通过此对象调用start()方法。
public class ThreadTest{
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
for (int i = 0; i < 10000; i++) {
System.out.println(Thread.currentThread().getName()+":-------");
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+i);
}
}
}
}
那问题来了
1、为什么不能直接调用run()方法,非得使用子类对象调用start()方法。
原因是:
用run()方法只是java中简单的对象调用方法的作用,只有主程序一条执行路径
而通过调用Thread类的 start()方法来启动一个线程,此线程处于就绪(可运行)状态,并没有运行,然后多个线程相互争夺cpu时间片,一旦得到cpu时间片,就开始执行run()方法,这也是为什么多线程执行结果参差不齐
2、线程可以多次调用start()方法多次启动线程吗
No 绝对不可以,当已经调用start()方法后,再次调用会报*IllegalThreadStateException()*异常
原因是:当线程调用start()方法后,会首先进行判断线程状态,当已经调用过此方法后,不满足条件,因此会报异常
2、实现Runnable接口(推荐)
创建一个实现Runnable接口的类,实现Runnable中的run()方法,创建实现类对象并作为参数传递到Thread类的构造方法中,通过Thread类的对象调用start()方法,代码如下
public class ThreadTest2 {
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
new Thread(myThread1).start();
for (int i = 0; i < 100; i++) {
System.out.println("======================");
}
}
}
class MyThread1 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+"-------------"+i);
}
}
}
}
两种方法的联系与区别
区别:
extends关键字是单继承,一个类只能继承一个父类,而实现方法解决了单继承性的局限性
实现方法更适合处理含有共享资源的多线程情况
联系:
本质上Thread类实现的也是Runnable接口,都需要重写run()方法
3、实现Callable接口(进阶)
首先创建一个Callable接口的实现类,实现Callable中call()方法。创建Callable实现类的对象,并作为参数传递到FutureTask构造器中,并创建FutureTask对象,并将该对象作为参数传递到Thread构造器中,创建对象,调用start()方法,最后获取call()方法的返回值。。。(疯狂套娃)
public class ThreadTest3 implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
System.out.println(i);
sum+=i;
}
return sum;
}
}
class MyThread3{
public static void main(String[] args) {
ThreadTest3 threadTest3 = new ThreadTest3();
FutureTask futureTask = new FutureTask(threadTest3);
new Thread(futureTask).start();
try {
//get()返回值即为call()的返回值
Object o = futureTask.get();
System.out.println("总和为:"+o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
Callable与Runnable比较
- call()方法具有返回值
- call()方法可以抛出异常
- Callable支持泛型
- 需要借助FutureTask类
FutureTask是Future接口的唯一实现类,而Future接口可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
4、线程池
class MyThread4 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.创建指定数量的线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
//2.执行线程操作,提供实现Runnable或Callable接口的对象
executorService.execute(new MyThread4());//适用于Runnable
// executorService.submit();//适用于Callable
//关闭连接池
executorService.shutdown();
}
}
好处:
提高响应速度
降低资源消耗
便于线程管理
最后,奉上一些常用的方法:
方法 | 说明 |
---|---|
start() | 启动当前线程,调用run()方法 |
currentThread() | 返回当前执行的线程 |
getName() | 获取当前线程的名字 |
setName() | 设置当前线程的名字 |
yield() | 释放当前cpu的执行权 |
join() | 使正在执行的线程进入阻塞状态,直到join的线程执行完成,才会结束阻塞状态 |
sleep() | 在指定时间内,当前线程使阻塞状态,单位毫秒 |
isAlive() | 判断当前线程是否存活 |
如有错误之处,感谢评论指出,虚心请教,共同学习