正文

java多线程：创建线程的四种方式

PS-Jerry  2022-05-05  345

关键词：

创建线程的四种方式

方式一：继承自Thread 类

方法步骤

1.创建一个继承于Thread类的子类
2.重写Thread 类的 run()方法-> 将线程的执行操作声明到run()中
3.创建Thread 类的子类对象
4.通过此对象调用start() 方法

例如：输出0~100 以内所有的偶数

public class ThreadInheritTest {
    public static void main(String[] args) {
        //3.new 一个继承自Thread类的对象
        MyInheritThread myThread = new MyInheritThread();

        //4.启动线程
        myThread.start();
    }
}

//1.创建一个继承自Thread 的子类
class MyInheritThread extends Thread {
    //2.重写父类中Thread 的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

注意：我们不能通过run方法启动线程，而是应该通过start方法启动线程。

方式二：实现Runnable 接口

方法步骤

1.创建一个实现Runnable接口的类。
2.重写Runnable 类的 run()方法-> 将线程的执行操作声明到run()中
3.创建实现当前Runnable 接口类的对象。
4.将上述对象作为参数传入到Thread 类的构造器中。
5.通过Thread类的对象调用start() 方法启动线程。

例如：输出1~100 以内所有的偶数

public class ThreadRunnableTest {
    public static void main(String[] args) {
        MyRunnableThread myRunnableThread = new MyRunnableThread();
        Thread t1 = new Thread(myRunnableThread);
        t1.start();
    }
}


class MyRunnableThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

方式三：实现Callable 接口

实现Callable 接口，该接口是JDK 5.0 中新增的。

步骤

1.创建一个实现Callable 的实现类
2.实现call()方法，将此线程需要执行的操作声明到call()方法中，注意该方法是有返回值的。
3.创建Callable接口实现类的对象
4.将此Callable实现类的对象(numThread)传递FutureTask构造其中，创建FutureTask对象。
5.将FutureTask创建的对象，传递到Thread构造器中，在start该线程。
6.如果关心线程中call()方法的返回值，则可以用个futureTask.get() 来抓取返回值。

例如：如下代码用于计算0~100以内，所有偶数的和

package com.jerry.thread10;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadCallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        //4.将此Callable实现类的对象(numThread)传递FutureTask构造其中，创建FutureTask对象。
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);

        //5.将FutureTask创建的对象，传递到Thread构造器中，在start该线程。
        new Thread(futureTask).start();

        //6.如果关心线程中call方法的返回值，则可以用个futureTask.get() 来抓取返回值。
        try {
            //拿到其返回值
            Integer sum = futureTask.get();
            System.out.println("总和为: " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.创建一个实现Callable 的实现类
class NumThread implements Callable<Integer> {

    //2.实现call方法，将此线程需要执行的操作声明到call方法中，注意该方法是有返回值的。
    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }

        return sum;
    }
}

注意：如何理解Callable 接口更强大？

call() 方法是有返回值得。

call() 可以抛出异常，被外面的操作捕获，获取异常信息。

Callable 中是支持泛型的，这个泛型就是用futureTask.get()的返回值。

方式四：使用线程池（ThreadPool）

1、使用线程池的好处

1.提高了响应速度(减少了创建线程的时间)
2.降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
3.便于管理，如可设置如下属性管理线程池
- 1. corePoolSize 线程池大小
- 1. maximumPoolSize 最大线程数
- 1. keepAliveTime 线程没有任务时，最多保持多长时间后会终止

2、步骤

这里我们只演示了通过Runnable 实现接口方式构建run方法

1.创建一个固定大小的线程池
2.设置线程池属性
3.使用execute执行当前线程，excute适合用于Runnable方式，当线程方法是Callable时要用submit
4.使用shutdown方法关闭当前线程，线程池不用了，则关闭当前线程。

例如：如下代码创建了固定可容纳10个线程的线程池，当中有两个线程，分别输出奇数和偶数

package com.jerry.thread10;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPoolTest {

    public static void main(String[] args) {
        //1.创建一个固定大小的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.设置线程池属性
        ThreadPoolExecutor executor1 = (ThreadPoolExecutor) service;
        executor1.setCorePoolSize(10);

        //3.执行当前线程，适合用于Runnable，Callable 要用submit
        service.execute(new NumThread1());//执行线程1，用于输出偶数
        service.execute(new NumThread2());//执行线程2，用于输出奇数
        //4.关闭当前线程，线程池不用了，则关闭当前线程
        service.shutdown();
    }
}

class NumThread1 implements Runnable {
    //输出偶数
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumThread2 implements Runnable {
    //输出奇数
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

java多线程实现的四种方式

Java多线程实现方式主要有四种：继承Thread类；实现Runnable接口；实现Callable接口通过FutureTask包装器来创建Thread线程；使用接口ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，后... 查看详情

java多线程实现的四种方式

...（A16登陆）批发价格优势，跑量联系V信:gao66561 Java多线程实现的四种方式继承Thread类，重写run方法实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target通过Callable和FutureTask创建线程通过... 查看详情

java多线程实现的四种方式

实现多线程的四种方式

Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，后两种... 查看详情

java多线程实现的四种方式

...例对象作为Thread构造函数的target通过Callable和FutureTask创建线程通过线程池创建线程前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果后面两种可以归结成一类：... 查看详情

java实现多线程的四种方式

1.继承Thread类publicclassmyThreadextendsThread{　　@Override 　　publicvoidrun(){ 　　　　System.out.println("现在的线程是："+Thread.currentThread()); 　　} 　　publicstaticvoidmain(String[]args){ 　　　　newmyThread().star 查看详情

java创建线程的四种方法（转）

java中创建线程的四种方法以及区别Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示：1）继承Thread类创建线程2）实现Runnable接口创建线程3）使用Callable和Future... 查看详情

java实现多线程的四种实现方式

以计算0到1000之间的和为例importjava.util.ArrayList;importjava.util.LinkedList;importjava.util.List;importjava.util.concurrent.*;importjava.util.concurrent.atomic.AtomicInteger;publicclassMain{//求1~N全部整数的和，会上溢in 查看详情

java多线程实现的四种方式

在导入java项目的时候，eclipse会出现finish不能点击的情况。在导入项目的时候，需要注意的几点。1、项目要从其他的路径导入eclipse的工作路径中，而不是直接从eclipse的工作路径中导入项目。2、因为某个项目名字已经存在，导入... 查看详情

多线程实现的四种方式

参考技术A多线程实现的四种方式Thread裸线程、Executor服务、ForkJoin框架、Actor模型。1、Thread裸线程线程是并发最基本的单元。Java线程本质上被映射到操作系统线程，并且每个线程对象对应着一个计算机底层线程。每个线程有自己... 查看详情

创建线程的四种方式

https://www.cnblogs.com/zhou-test/p/9811771.html 查看详情

创建线程的方式以及executors的四种线程池(代码片段)

创建线程有几种方式？面试常问的问题，一般回答3种方式，及格；如果你能具体的说4种，那你就满分了，第四种是通过Executors创建线程池。先来说说创建线程的3种方式：一、继承Thread类publicclassExtendsT... 查看详情

juc-线程创建的四种方式+原理分析(代码片段)

文章目录一、继承Thread1、创建空线程2、创建Thread线程二、实现Runnable1、代码实现2、实现原理3、继承Thread和实现Runnable的优缺点三、实现Callable交给FutureTask1、Callable2、FutureTask3、RunnableFuture4、Future5、原理分析6、代码实现7、分析... 查看详情

juc-线程创建的四种方式+原理分析(代码片段)

创建线程

创建线程的四种方式以及区别Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示：1）继承Thread类创建线程2）实现Runnable接口创建线程3）使用Callable和Future创... 查看详情

创建线程的方式以及executors的四种线程池(代码片段)

浅析java中的四种线程池

1.使用线程池的好处　　2.JUC中几种常用的线程池　　java.util.concurrent包下的Executors工厂类，提供了一系列的线程池的创建方法，其构造方法如下：publicThreadPoolExecutor(intcorePoolSize,　　　　　　　　　　//线程池线程核心数量... 查看详情

java线程同步的四种方式详解(代码片段)

什么是线程同步当使用多个线程来访问同一个数据时，将会导致数据不准确，相互之间产生冲突，非常容易出现线程安全问题比如多个线程都在操作同一数据，都打算修改商品库存，这样就会导致数据不一致... 查看详情

正文

java多线程：创建线程的四种方式

创建线程的四种方式

方式一：继承自Thread 类

例如： 输出0~100 以内所有的偶数

方式二：实现Runnable 接口

例如：输出1~100 以内所有的偶数

方式三：实现Callable 接口

例如：如下代码用于计算0~100以内，所有偶数的和

方式四：使用线程池（ThreadPool）

例如：如下代码创建了固定可容纳10个线程的线程池，当中有两个线程，分别输出奇数和偶数

java多线程实现的四种方式

java多线程实现的四种方式

java多线程实现的四种方式

实现多线程的四种方式

java多线程实现的四种方式

java实现多线程的四种方式

java创建线程的四种方法（转）

java实现多线程的四种实现方式

java多线程实现的四种方式

多线程实现的四种方式

创建线程的四种方式

创建线程的方式以及executors的四种线程池(代码片段)

juc-线程创建的四种方式+原理分析(代码片段)

juc-线程创建的四种方式+原理分析(代码片段)

创建线程

创建线程的方式以及executors的四种线程池(代码片段)

浅析java中的四种线程池

java线程同步的四种方式详解(代码片段)

例如：输出0~100 以内所有的偶数