线程的创建
方法一:继承于Thread类
步骤
1、 创建一个继承于Thread类的子类
2、 重写Thread类中的run( )方法
3、 将此线程执行的操作声明在run方法中
4、 创建Thread类的子类对象
5、 通过此对象调用start( )方法
* start方法作用
* 启动当前线程
* 调用当前线程的run( )方法
代码实现
public class Test1 {
public static void main(String[] args) {
//3. 创建Thread类的子类对象
MyThread myThread = new MyThread();
//4. 通过此对象调用start()方法
myThread.start();
}
}
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
//2. 重写Thread类中的run()方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
注意事项
1、 不能通过直接调用run()的方式去启动线程,启动线程只能使用start()方法
2、 每个线程只能启动一次,如果多次启动,会报IllegalThreadStateException异常
3、 要想创建多个线程,就造多个对象
方法二:实现Runnable接口
步骤
1、 创建一个实现Runnable接口的类
2、 实现类去实现Runnable类中抽象方法:run()
3、 创建实现类的对象
4、 将此对象作为参数传入到Thread类中的构造器中,创建Thread类的对象
5、 通过Thread类的对象,调用start()
* start()作用
* 启动线程
* 调用当前线程的run()
* 调用了Runnable类型的target的run()
代码实现
public class Test2 {
public static void main(String[] args) {
//3. 创建实现类的对象
MyselfThread myselfThread = new MyselfThread();
//4. 将此对象作为参数传入到Thread类中的构造器中,创建Thread类的对象
Thread thread = new Thread(myselfThread);
//5. 通过Thread类的对象,调用start()
thread.start();
}
}
//1. 创建一个实现Runnable接口的类
class MyselfThread implements Runnable{
//2. 实现类去实现Runnable类中的run()方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
方法一和方法二对比
两者联系
- Thread类本身也是实现了Runnable接口
- 都需要重写run(),将线程要实现的逻辑声明在run()方法中
优先选择实现Runnable接口的方式
原因:
1、 实现的方式没有类的单继承性的局限性
2、 实现的方式更适合来处理多个线程有共享数据的情况
方法三:实现Callable接口
比Runnable相比的好处
1、 可以有返回值
* 需要借助Future接口
* 可以对具体的Runnable、Callable任务的执行结果进行取消、查询是否完成获取结果等
* 唯一的实现类是FutureTask
* 同时实现了Runnable、Future接口
* 既可以作为Runnable被线程执行,又可以作为Future得到
2、 方法可以抛出异常,被外面的操作捕获,获取异常的信息
3、 支持泛型的返回值
步骤
1、 创建一个实现Callable接口的实现类
2、 实现call方法,将此线程需要执行的操作声明在call方法中
* call方法可以有返回值
3、 创建Callable接口实现类的对象
4、 将此Callable接口的实现类对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
5、 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并start()方法调用
6、 获取Callable中的call方法的返回值
* 使用futureTask.get()
* get()方法返回值即为FutureTask参数callable实现类重写call的返回值
代码实现
public class Test3 {
public static void main(String[] args) {
//3. 创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4. 将此Callable接口的实现类对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并start()方法调用
Thread thread = new Thread(futureTask);
thread.start();
//6. 获取Callable中的call方法的返回值
try{
Object sum = futureTask.get();
System.out.println(sum);
}catch (InterruptedException e){
e.printStackTrace();
}catch (ExecutionException e){
e.printStackTrace();
}
}
}
//1. 创建一个实现Callable接口的实现类
class NumThread implements Callable{
//2. 实现call方法,将此线程需要执行的操作声明在call方法中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if(i % 2 == 0){
sum = sum + i;
}
}
return sum;
}
}
方法四:使用线程池
好处
1、 提高响应速度
2、 降低资源消耗
3、 便于线程管理
步骤
1、 提供指定线程数量的线程池
2、 执行指定的线程操作,需要提供一个实现Runnable接口或Callable接口实现类的对象
3、 关闭连接池