启动线程的方式Android 线程启动的两种方式

转载

hochie 2023-11-03 17:21:44

文章标签 启动线程的方式Android 多线程线程池类对象创建线程 文章分类 Android 移动开发

1.1 通过继承 thread 来开启线程

/**

继承方式实现线程的启动
我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？
继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？如下代码：
Thread t1 = new Thread();
t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。
创建线程的目的是什么？
是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。
对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。
Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。
所以进行了重写run方法动作。

*/
import lombok.extern.slf4j.Slf4j;
 @Slf4j
 public class ExtendsThread extends Thread {public ExtendsThread(String name){
    super(name);
}

public ExtendsThread() {
}
@Override
public void run() {

    for(int i=0;i<10;i++){
        log.info(Thread.currentThread().getName()+",i="+i);
    }
}}

1.2 通过实现Runnable接口：
import lombok.extern.slf4j.Slf4j;

/**

通过实现runnable来实现线程的启动
实现Runnable的原理
为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。
线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，
这样，线程对象创建时就可以明确要运行的线程的任务。
实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。
实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。
实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。
Runnable接口对线程对象和线程任务进行解耦。

•  */
 @Slf4j
 public class ImplThread implements Runnable {
 @Override
 public void run() {
 for(int i=0;i<100;i++){
 log.info(“我的线程 :”+i);
 }
 }
 }

测试类：

import lombok.extern.slf4j.Slf4j;
@Slf4j
 public class ThreadTest {public static void main(String[] args) {


    /**
     * -------------------------通过继承启动线程-----------------------------------------------------------------------
     */


    //ExtendsThread myThread=new ExtendsThread("新建线程");

   /* ExtendsThread myThread1 = new ExtendsThread();
    ExtendsThread myThread2 = new ExtendsThread();

    myThread1.run();//没有开启新线程，在主线程调用方法
    myThread2.start();//开启了新的线程，调用jvm，在主线程调用方法*/

    /**
     * -------------------------通过实现runnable来启动线程--------------------------------------------------------------
     */

   /*  //创建线程执行目标类对象
    Runnable runn = new ImplThread();
    //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
    Thread thread1 = new Thread(runn);
    Thread thread2 = new Thread(runn);

    //支线程，启动线程
    thread1.start();
    thread2.start();
    //主线程路径
    for(int i=0;i<10;i++){
        log.info("主线程 ："+i);
    }*/

    /**
     * -------------------------使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作--------------------------
     */

    //方式1：创建线程对象时，直接重写Thread类中的run方法


   /* new Thread() {
        @Override
        public void run() {

            for (int i = 0; i < 20; i++) {
              log.info(Thread.currentThread().getName()+"---I"+i);
            }
        }
    }.start();*/

    //方式2：使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法

   /* Runnable runn = new Runnable() {
        @Override
        public void run() {
            for (int y = 0; y < 20; y++) {
                log.info(Thread.currentThread().getName() + "---Y" + y);
            }
        }
    };

    new Thread(runn).start();*/
}}

2.1 使用线程池方式–Runnable接口

import lombok.extern.slf4j.Slf4j;
@Slf4j
 public class ImplThread2 implements Runnable {@Override
public void run() {
    log.info("我要一个教练");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("教练来了-----"+Thread.currentThread().getName());
    log.info("教我游泳，教完后，教练回去了");

}}

测试类：

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;@Slf4j
 public class ThreadPoolTest {/**
 * 我们详细的解释一下为什么要使用线程池？
 *
 * 在java中，如果每个请求到达就创建一个新线程，开销是相当大的。
 * 在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。
 * 除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。
 * 如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。
 * 为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，
 * 特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
 *
 * 线程池主要用来解决线程生命周期开销问题和资源不足问题。
 * 通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。
 * 这样，就可以立即为请求服务，使用应用程序响应更快。
 * 另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
 *
 *  Executors：线程池创建工厂类
 *
 *  public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象
 *
 *  ExecutorService：线程池类
 *
 *  Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
 *
 *  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
 *
 */

public static void main(String[] args) {

    //创建(3个)线程池对象
    ExecutorService service = Executors.newFixedThreadPool(3);
    //创建实例对象
    ImplThread2 runn=new ImplThread2();
    //自己创建线程对象的方式
    Thread  thread=new Thread(runn);
    //thread.start(); //---> 调用ImplThread中的run()

    //从线程池中获取线程对象,然后调用ImplThread中的run()
    service.submit(runn);
    //再获取个线程对象，调用ImplThread中的run()
    service.submit(runn);
    service.submit(runn);
    //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
    //关闭线程池
    service.shutdown();
}}

2.2 使用线程池方式—Callable接口：

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;
@Slf4j
 public class CallImplThread implements Callable {int a;
int b;
public CallImplThread(int a, int b) {
    this.a = a;
    this.b = b;
}
public CallImplThread() {
}
@Override
public Integer call() {
    return a+b;
}}

测试类：

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 @Slf4j
 public class ThreadPoolTest2 {/**
 * 2.3 使用线程池方式—Callable接口
 * <p>
 * l Callable接口：与Runnable接口功能相似，用来指定线程的任务。
 * 其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
 * <p>
 * l ExecutorService：线程池类
 * <p>
 * l <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
 * <p>
 * l Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
 * <p>
 * <p>
 * l 使用线程池中线程对象的步骤：
 * <p>
 * l 创建线程池对象
 * <p>
 * l 创建Callable接口子类对象
 * <p>
 * l 提交Callable接口子类对象
 * <p>
 * l 关闭线程池
 */

public static void main(String[] args) throws InterruptedException, ExecutionException {

    //获取线程池对象(3个)
    ExecutorService service = Executors.newFixedThreadPool(3);
    //创建Callable对象

    CallImplThread c = new CallImplThread(100,50);

    //从线程池中获取线程对象,然后调用MyRunnable中的run()
    Future<Integer> result = service.submit(c);

    //再获取个教练
    Future<Integer> result1 =service.submit(c);
    Future<Integer> result2 =service.submit(c);
    //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
    //关闭线程池

    log.info(result.get()+result1.get()+result2.get()+"");
    service.shutdown();
}}

3.0 总结
创建线程的方式

方式1，继承Thread线程类：
1，自定义类继承Thread类
2，在自定义类中重写Thread类的run方法
3，创建自定义类对象(线程对象)
4，调用start方法，启动线程，通过JVM，调用线程中的run方法

方式2，实现Runnable接口：
1，创建线程任务类实现Runnable接口
2，在线程任务类中重写接口中的run方法
3，创建线程任务类对象
4，创建线程对象，把线程任务类对象作为Thread类构造方法的参数使用
5，调用start方法，启动线程，通过JVM，调用线程任务类中的run方法

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。