专注于 JetBrains IDEA 全家桶,永久激活,教程
持续更新 PyCharm,IDEA,WebStorm,PhpStorm,DataGrip,RubyMine,CLion,AppCode 永久激活教程

线程的创建

线程的创建

方法一:继承于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、 关闭连接池

未经允许不得转载:搜云库技术团队 » 线程的创建

JetBrains 全家桶,激活、破解、教程

提供 JetBrains 全家桶激活码、注册码、破解补丁下载及详细激活教程,支持 IntelliJ IDEA、PyCharm、WebStorm 等工具的永久激活。无论是破解教程,还是最新激活码,均可免费获得,帮助开发者解决常见激活问题,确保轻松破解并快速使用 JetBrains 软件。获取免费的破解补丁和激活码,快速解决激活难题,全面覆盖 2024/2025 版本!

联系我们联系我们