创建多线程有几种方法？如何创建线程？

最新推荐文章于 2024-09-18 08:23:46 发布
最新推荐文章于 2024-09-18 08:23:46 发布
阅读量3.3k 收藏 16
点赞数 8
文章标签： thread android android 异步 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dz_hexiang/article/details/78069736
版权
多线程有几种实现方法？

多线程实现又3种方法，其中前两中是常用的方法，推荐第二种方法，一个类应该在其修改或者加强是才继承

1.继承Thread类，重写run()方法，实例化该类，调用线程start()方法

(1)自定义类，继承Thread类，重写run()方法

(2)创建该Thread子类实例

(3)然后调用线程start()方法


    public class TestThread extends  Thread{
        @Override
        public void run() {
            printThreadMsg("1.2.new TestThread run");
        }
    }
    /**
     * 打印线程信息
     * @param msg
     */
    private void printThreadMsg(String msg)
    {
        System.out.println(msg+":threadName:"+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());
    }

        /**
         * 1.1 匿名内部类（继承Thread类，重写run()方法）
         */
        new Thread(){
            @Override
            public void run() {
                printThreadMsg("1.1 new Thread() run");
            }
        }.start();
        /**
         * 1.2 继承Thread类，重写run()方法
         */
        new TestThread().start();

2.实现Runnable接口，并实现该接口的run()的方法，

具体步骤：

(1)自定义类，并实现Runnable接口，实现run()方法

(2)创建Thread子类实例:用实现Runnable接口的对象作为参数实例化个Thread对象

(3)然后调用线程start()方法

    public class TestRunnable implements  Runnable{
        @Override
        public void run() {
            printThreadMsg("2.2.TestRunnable run");
        }
    }


   /**
         * 2.1实现Runnable接口，并实现该接口的run()的方法，然后用实现Runnable接口的对象作为参数实例化Thread对象
         */
        new Thread(new TestRunnable()).start();

        /**
         * 2.2实现Runnable接口，并实现该接口的run()的方法，然后用实现Runnable接口的对象作为参数实例化Thread对象
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                printThreadMsg("2.2. new Thread.new Runnable run");
            }
        }).start();



3.实现Callable接口，重写call()方法

(1)自定义类，实现Callable接口，实现call()方法

(2)实例化ExecutorService 对象，实例化个刚刚自定义类(实现Callable接口)的对象，把它作为参数调用submit()方法

(3)注意get()方法获取结果会造成阻塞

    public static  class   TestCallable implements Callable{
        @Override
        public Object call() throws Exception {
            /**
             * 沉睡6秒，模拟耗时操作
             */
            Thread.sleep(6000);
            System.out.println("3.TestCallable  call:threadName:"+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());

            return "这是 TestCallable call 执行完 返回的结果";
        }
    }

      /**
         *实现Callable接口，重写call()方法
         */
        ExecutorService mExecutorService= Executors.newSingleThreadExecutor();
        Future future=mExecutorService.submit(new TestCallable());
        try {
            /**
             * future.get()用来获取结果，  会造成线程阻塞，直到call()结束
             * 等待线程结束，并且返回结果
             * 线程阻塞了
             */
        String result= String.valueOf(future.get());
        System.out.println("3.TestCallable call return:"+result+","+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());

        } catch (Exception e) {
            e.printStackTrace();
        }

最后附上所有代码

package com.hex168.demo.therad;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import java.lang.ref.WeakReference;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * author：dz_hexiang on 2017/9/23 13:06
 * email：472482006@qq.com
 * 测试线程创建
 */
public class ThreadActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_therad);
        /**
         * 1.1 匿名内部类（继承Thread类，重写run()方法）
         */
        new Thread(){
            @Override
            public void run() {
                printThreadMsg("1.1 new Thread() run");
            }
        }.start();
        /**
         * 1.2 继承Thread类，重写run()方法
         */
        new TestThread().start();

        /**
         * 2.1实现Runnable接口，并实现该接口的run()的方法，然后用实现Runnable接口的对象作为参数实例化Thread对象
         */
        new Thread(new TestRunnable()).start();

        /**
         * 2.2实现Runnable接口，并实现该接口的run()的方法，然后用实现Runnable接口的对象作为参数实例化Thread对象
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                printThreadMsg("2.2. new Thread.new Runnable run");
            }
        }).start();


        /**
         *实现Callable接口，重写call()方法
         */
        ExecutorService mExecutorService= Executors.newSingleThreadExecutor();
        Future future=mExecutorService.submit(new TestCallable());
        try {
            /**
             * future.get()用来获取结果，  会造成线程阻塞，直到call()结束
             * 等待线程结束，并且返回结果
             * 线程阻塞了
             */
        String result= String.valueOf(future.get());
        System.out.println("3.TestCallable call return:"+result+","+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());

        } catch (Exception e) {
            e.printStackTrace();
        }
        /**
         * handler 及runnable都是在主线程
         */
        handler.post(handlerRunnable);
    }

    public class TestThread extends  Thread{
        @Override
        public void run() {
            printThreadMsg("1.2.new TestThread run");
        }
    }

    public class TestRunnable implements  Runnable{
        @Override
        public void run() {
            printThreadMsg("2.2.TestRunnable run");
        }
    }

    public Runnable handlerRunnable =new Runnable() {
        @Override
        public void run() {
            printThreadMsg("4.handler handlerRunnable run");
        }
    };

    /**
     * 打印线程信息
     * @param msg
     */
    private void printThreadMsg(String msg)
    {
        System.out.println(msg+":threadName:"+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());
    }

    private MyHandler handler=new MyHandler(this);
    static class MyHandler extends Handler{
        WeakReference<Activity> activityWeakReference;

        MyHandler(Activity c)
        {
            activityWeakReference=new WeakReference<Activity>(c);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    }

    public static  class   TestCallable implements Callable{
        @Override
        public Object call() throws Exception {
            /**
             * 沉睡6秒，模拟耗时操作
             */
            Thread.sleep(6000);
            System.out.println("3.TestCallable  call:threadName:"+Thread.currentThread().getName()+",threadId:"+Thread.currentThread().getId());

            return "这是 TestCallable call 执行完 返回的结果";
        }
    }
}

运行结果



清风依然
关注
详解Python并发编程之创建多线程的几种方法
09-18
在Python中，创建多线程主要有两种方法：函数式和面向对象式。 1. **学会使用函数创建多线程** 在Python中，我们可以使用内置的`threading`模块的`Thread`类来创建线程。`Thread`类的构造函数`Thread(target=func,...
创建多线程（8种方式）
qq_1757537040的博客
03-29 9521
无论有多少种形式，创建多线程的真正的方法， 其实只有两种： > 继承 Thread 类 > 实现 Runnable 接口 其它形式都是这两种方式的变体。 1、继承 Thread 类 ①实现方式 第一步：继承 Thread 类 第二步：重写 run() 方法 第三步：创建 Thread 子类对象 第四步：调用 start() 方法启动线程 ②start() 方法和 run() 方法区别 调用 run() 方法仅仅只是调用了一个子类中重写的父类...
第一章 线程
qq_39354297的博客
09-08 364
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
【JAVA】多线程的创建、线程池创建线程的方式（超详细）
最新发布
A的博客
09-18 1153
当应用程序希望在任务提交失败时立刻知道，并进行错误处理或日志记录时，这种策略是合适的。例如，当任务的失败可能意味着系统的严重问题，开发者希望程序能立刻响应并处理这些异常情况时，可以使用。：当任务丢失是可以接受的，或者任务的重要性相对较低时，可以使用这个策略。：当系统希望优先处理最近提交的任务，并丢弃最早的任务以腾出空间时，可以使用这个策略。即，任务不会被丢弃或丢失，而是会由提交任务的线程自己执行。：这个策略会丢弃任务队列中最旧的任务，然后尝试提交新的任务。，即立即终止任务提交，并通知提交者任务提交失败。
创建线程的四种方式
m0_58473539的博客
01-12 5039
无
创建多线程的四种方式
qq_39232813的博客
03-17 3972
创建多线程的四种方式 方式一：继承于Thread类 创建一个继承于Thread类的子类 重写Thread类的run（）—>将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start（） public class ThreadTest1 { public static void main(String[] args) { Thread1 test1 = new Thread1(); Thread1 test2 = new T
线程创建的四种方法
咸鱼老潘的编码生活
09-23 2732
线程的四种创建方法
java 创建线程的几种方式
08-31
在Java编程语言中，创建线程是实现多任务并发处理的关键。本文将详细阐述两种主要的线程创建方式，以及它们的特点和使用场景。...希望本文提供的内容能对你的学习和工作有所帮助，并激发你对Java多线程更深入的探索。
java 多线程的几种实现方法总结
08-29
Java 多线程的几种实现方法总结 Java 多线程是指在同一个程序中可以有多条执行线索同时执行，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行。为了帮助大家更好地理解和掌握 Java 多线程的知识，...
线程创建常用的四种方式
学英语的程序员
03-24 2万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 1.继承Thread类创建线程 通过继承Thread类来创建并启动多线程的一般步骤如下 1】d定义Threa..
创建线程的几种方式
inexaustible的博客
01-12 2988
创建线程的几种方式
线程——创建线程的三种方式
m0_68519425的博客
04-26 1719
if(Ticket>0){System.out.println("我在"+Thread.currentThread().getName()+"抢到了第"+ Ticket-- +"张车票");if(Ticket>0){System.out.println("我在"+this.getName()+"抢到了第"+ Ticket-- +"张车票");这个方法也是通过父类来完成的，定义一个有参的构造器，然后调用父类的有参构造器，来实现对线程名字的设置。//start()方法是Thread类中的方法。
线程的4种创建方式
激流丶的博客
06-05 3256
多线程创建的4种方式
线程的创建方式
weixin_46760166的博客
09-19 9139
1、继承 Tread类， 重写 run方法2、实现 Runnable接口，实现 run方法3、实现 Callable接口，实现 call方法，该方式可以获取线程的执行结果。
创建多线程的四种方法
Small_Pang的博客
08-19 665
创建多线程的四种方法 方法一：继承Thread类创建线程 public class MyThread extends Thread { @Override public void run() { for (int i = 0; i<= 20; i++) { if(i%2 == 0){ System.out...
java创建线程的三种方式及其对比
热门推荐
longshengguoji的专栏
11-14 17万+
Java中创建线程主要有三种方式： 一、继承Thread类创建线程类 （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 （2）创建Thread子类的实例，即创建了线程对象。 （3）调用线程对象的start()方法来启动该线程。 package com.thread; public class Firs
线程的4种创建方式及区别
weixin_38446891的博客
08-04 9859
从 1、继承Thread类 2、实现Runnable接口 3、实现Callable接口 4、创建线程池
创建线程有哪几种方式？
09-11
### 回答1： 在 Python 中创建线程有以下几种方式: 1. 使用 `threading` 模块: 使用这种方式需要创建一个 `Thread` 类的实例, 然后调用它的 `start()` 方法来启动新线程。 2. 使用 `_thread` 模块: 这种方式与使用 `threading` 模块类似, 也需要调用 `start_new_thread()` 函数来启动新线程。 3. 使用多进程: Python 中的 `multiprocessing` 模块可以轻松地创建新的进程。 4. 使用其他第三方库: 例如 `gevent` 和 `concurrent.futures` 等库也可以用来创建线程。 ### 回答2： 在Java中，创建线程有以下几种方式： 1. 继承Thread类：继承Thread类并重写其run方法，然后实例化该类的对象，调用start方法启动线程。示例代码如下： ``` public class MyThread extends Thread { @Override public void run() { // 线程要执行的代码 } } // 创建并启动线程 MyThread thread = new MyThread(); thread.start(); ``` 2. 实现Runnable接口：实现Runnable接口，并实现其run方法，然后创建Thread对象并将Runnable实例作为参数传递给Thread对象，最后调用start方法启动线程。示例代码如下： ``` public class MyRunnable implements Runnable { @Override public void run() { // 线程要执行的代码 } } // 创建并启动线程 MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); ``` 3. 使用Callable和Future：使用Callable接口代替Runnable接口，重写call方法，然后创建ExecutorService对象，通过submit方法提交Callable对象，最后得到Future对象并通过get方法获取结果。示例代码如下： ``` public class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { // 线程要执行的代码 return result; } } // 创建线程池并提交Callable对象 ExecutorService executor = Executors.newFixedThreadPool(1); MyCallable callable = new MyCallable(); Future<Integer> future = executor.submit(callable); // 获取线程结果 Integer result = future.get(); // 关闭线程池 executor.shutdown(); ``` 通过以上几种方式，可以灵活地创建和启动线程，并执行相应的任务。 ### 回答3： 创建线程的方式有以下几种： 1. 使用继承Thread类：创建一个新的类，继承自Thread类，并重写run()方法，在run()方法中定义线程要执行的任务。然后实例化这个新类的对象，并调用对象的start()方法来启动线程。 2. 实现Runnable接口：创建一个新的类，实现Runnable接口，并实现其中的run()方法。然后实例化这个新类的对象，并将对象作为参数传递给Thread类的构造方法创建Thread对象。最后调用Thread对象的start()方法启动线程。 3. 使用Callable和Future接口：创建一个新的类，实现Callable接口，并实现其中的call()方法。然后利用ExecutorService线程池的submit()方法提交Callable对象，得到一个Future对象，通过Future对象的get()方法获取线程的返回值。 4. 使用线程池：通过ExecutorService线程池来管理线程的创建和执行。可以使用ThreadPoolExecutor类来自定义线程池的大小和其他相关参数。 这些方式可以根据实际需求选择不同的方法来创建线程。使用继承Thread类或实现Runnable接口比较简单，适合简单的线程任务。使用Callable和Future接口可以获取线程的返回值。使用线程池可以有效管理线程的创建和执行，提高系统资源的利用率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值