四种创建线程方式

最新推荐文章于 2021-09-28 18:42:14 发布
最新推荐文章于 2021-09-28 18:42:14 发布
阅读量295 收藏 1
点赞数
分类专栏： java基础 文章标签： Thread Callable Runnable FutureTask 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40995778/article/details/80076976
版权

目录

一、继承于Thread类

  • java.lang.Thread是一个线程操作的核心类，JDK1.0提供。
  • Thread类本质上也是实现了Runnable接口的一个实例。
package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-24 07:37
 * @Description:
 */
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()-->将此线程执行的操作声明在run()中

    @Override
    public void run() {
        //打印100内的偶数
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();
    }
}

无论哪种方式实现多线程，线程启动一律调用Thread类提供的start()方法。

package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-24 07:37
 * @Description:
 */

public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的匿名子类
        new Thread() {
            @Override
            public void run() {
                //打印100内的偶数
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            }
        }.start();
    }
}

1.为什么要覆写run()方法？

Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。

2. start( )方法解析：

2.1功能

  • Ⅰ.启动当前线程
  • Ⅱ.调用当前线程的run()方法

2.2start( )方法工作流程

  • Ⅰ.首先检查线程状态是否为0（线程状态默认为0表示未启动），如果线程已经启动再次调用start()方法会抛出IllegalThreadStateException。也就是说，一个线程的start( )方法只能调用一次。
  • Ⅱ.通过start0()方法真正将线程启动。
  • Ⅲ.JVM调用start0()方法进行资源分配与系统调度，准备好资源启动线程后回调run()方法来执行线程的具体任务。

问题：为什么要通过start( )方法来调用run( )方法，而不是run( )直接执行？
只有通过调用start()方法，让JVM来调用start0()方法，这时JVM会进行资源分配与系统调度的准备工作；如果直接调用run()方法，就缺少了这些准备工作，相当于调用了一个普通的run()方法，就达不到启动线程的目的。

二、实现Runnable接口

1.引入（多窗口卖票）

package 卖票;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 卖票
 * @Author: mcc
 * @CreateTime: 2020-09-28 08:04
 * @Description:创建三个窗口卖票，总票数为100张；存在线程安全问题，待解决
 */
class Window extends Thread {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + ": 卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}

在这里插入图片描述
从结果来看是三个窗口各自卖了100张票，没有达到预期的三个窗口共卖100张票的目的。由于Window这个线程子类中提供的ticket属性是一个实例变量，在主类中创建了3个对象，就意味着每个对象有一份，在调用run方法的时候每个对象判断自己的ticket是否大于0，所以导致卖了300张票；要解决这个问题可以将ticket设为静态
在这里插入图片描述
这时每个对象共享同一个静态变量，如果不想将ticket设置为静态，那该怎么做呢？

2.实现Runnable接口创建多线程

package 线程创建;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-09-29 07:52
 * @Description:
 */
//1.创建一个实现Runnable接口的类
class MThread implements Runnable {
    //2.实现类去实现Runnable接口的抽象方法：run
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        //5.通过Thread类的对象调用start方法
        t1.start();
        t2.start();
    }
}

提问：
Thread对象通过调用start方法，从而调用了当前线程（Thread类）的run方法，为什么会调用到MThread类中实现的run方法？

//源码
@Override
public void run() {
	if (target != null) {
		target.run();
	}
}

/* What will be run. */
private Runnable target;

public Thread(Runnable target) {
	this(null, target, "Thread-" + nextThreadNum(), 0);
}
  1. 调用start方法时，所执行的是Thread类的run方法
  2. Thread类的run方法中，如果target不等于null，则调用target的run方法，所以我们要清楚target的run方法到底是什么
  3. 而target是Thread类中声明的Runnable类型的属性
  4. 构造器public Thread(Runnable target)中的形参恰好是target，相当于放到形参位置的MThread的对象去赋值target，然后Thread的run方法中，target被赋过值，所以不等于null，这时调用target的run方法，而target的run就是MThread对象所重写的run方法

3.Runnable接口实现多窗口卖票

package 卖票;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 卖票
 * @Author: mcc
 * @CreateTime: 2020-10-08 10:40
 * @Description:创建三个窗口卖票，总票数为100张；存在线程安全问题，待解决
 */
class Window1 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class Window1Test {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        Thread thread1 = new Thread(window1);
        Thread thread2 = new Thread(window1);
        Thread thread3 = new Thread(window1);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

在这里插入图片描述

比较创建线程的两种方式：
开发中优先选择实现Runnable接口的方式
原因：

  1. 实现方式没有类的单继承局限性
  2. 实现方式更适合来处理多个线程共享数据的情况

联系：public class Thread implementb Runnable
相同点：两种方式都需要重写run，将线程要执行的逻辑声明在run中

三、通过Callable接口实现多线程（Futuretask方式）

出现Callable接口实现多线程的原因：由于Runnable接口的run( )方法没有返回值，但是有些线程执行完后可能带来一些返回结果，为了解决这种问题，就出现了Callable接口实现多线程的方式。
在这里插入图片描述

package 线程创建;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-10-19 07:34
 * @Description:创建线程方式三：实现Callable接口，JDK5.0新增 计算100内偶数的和
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    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
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

如何理解实现Callable接口的方式创建多线程比Runnable方式更强大？

  1. call()可以有返回值
  2. call()可以抛出异常，被外面的操作捕获，获取异常信息
  3. Callable是支持范型的

四、线程池（开发常用）

1.背景

经常创建和销毁使用量特别大的资源，比如并发情况下的线程，对性能影响很大

2.思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具

3.好处

  • 提高响应速度（减少了创建新线程的时间）
  • 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  • 便于线程管理
    corePoolSize：核心池的大小
    maximumPoolSize：最大线程数
    KeepAliveTime：县城没有任务时最多保持多长时间后会终止
    。。。
package 线程创建;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: 线程创建
 * @Author: mcc
 * @CreateTime: 2020-10-21 07:32
 * @Description:使用线程池实现多线程
 */
class NumberThread implements Runnable {

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

class NumberThread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread1());//适用于Runnable
        //3.关闭连接池
        service.shutdown();
    }
}

4.线程池相关API

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

  • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnbale
  • <T>Future<T>submit(Callable<T>task)：执行任务，有返回值，一般用来执行Callable
  • void shutdown()：用来关闭连接池

Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

  • Executors.newCachedThreadPool()：创建一个可以根据需要创建新线程的线程池
  • Executors.newFixedThreadPool()：创建一个可重用固定线程数的线程池
  • Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
  • Executors.newScheduledThreadPool()：创建一个线程池，它可以排在给定延迟后运行命令或者定期的执行

五、区别

在这里插入图片描述

迷路的小绅士
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM原理
yuyingji的博客
06-15 2944
注明：转载文章。 一、什么是JVM JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏...
python线程的几种创建方式详解
09-18
使用threading模块创建线程时，通常有两种方式： 第一种是直接使用threading.Thread类来创建线程。这种方式需要定义一个继承自threading.Thread的类，并在该类中重写run()方法。在创建类的实例之后，通过调用实例的...
jvm原理
yangjinming24的专栏
07-11 4121
Java虚拟机是整个java平台的基石，是java技术实现硬件无关和操作系统无关的关键环节，是java语言生成极小体积的编译代码的运行平台，是保护用户机器免受恶意代码侵袭的保护屏障。JVM是虚拟机，也是一种规范，他遵循着冯·诺依曼体系结构的设计原理。冯·诺依曼体系结构中，指出计算机处理的数据和指令都是二进制数，采用存储程序方式不加区分的存储在同一个存储器里，并且顺序执行，指令由操作码和地址码组成，
面试必问之JVM原理
weixin_33889245的博客
07-13 5541
1：什么是JVMJVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,...
Jdk--Jvm
qingshunv的专栏
03-21 626
JDK和JRE的区别 　　JVM就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。但是光有JVM还不能成class的执行，因为在解释class的时候JVM需要调用解释
java 创建线程的几种方式
08-31
首先，第一种创建线程的方式是通过继承`java.lang.Thread`类。当你创建一个新的类并扩展Thread类时，你需要重写它的`run()`方法。例如： ```java public class MyThread extends Thread { public void run() { ...
创建线程的四种方式？
01-07
说说方式1与方式2的优缺点： 实现Runnable要好于继承Thread，原因： ① 实现的方式，解决单继承的局限性。 ② 实现的方式针对于共享数据的情况，操作起来更方便 ③ 实现的方式可以做到代码和数据的分离。 说说...
Java创建线程的两种方式
09-01
Java提供了两种主要的方式来创建线程，分别是继承`Thread`类和实现`Runnable`接口。这两种方式各有优缺点，适用于不同的场景。 ### 继承Thread类 当你选择继承`Thread`类来创建线程，你需要按照以下步骤操作： 1....
JVM 原理
撒忆雨
09-28 755
对线面试官系列 该播主除了一些不错的文章，推荐关注。 为什么需要Java内存模型？ Java从编译到执行，发生了什么？ 双亲委派机制 深入浅出 Java 内存模型 JVM内存结构 垃圾回收机制 CMS垃圾回收器 G1垃圾收集器 JVM调优 JVM性能监控与故障处理 BTrace动态日志跟踪 通过BTrace可以打印调用堆栈、参数、返回值，还可以进行性能监视、定位连接泄漏、内存泄漏、解决多线程竞争问题。 HotSwap技术：代码热替换技术，HotSpot虚拟机允许在不停止运行的情况下，更新已经加载的类的代码
java中JVM的原理
Fenice
02-26 1212
一、java虚拟机的生命周期： 　　Java虚拟机的生命周期 一个运行中的Java虚拟机有着一个清晰的任务：执行Java程序。程序开始执行时他才运行，程序结束时他就停止。你在同一台机器上运行三个程序，就会有三个运行中的Java虚拟机。 Java虚拟机总是开始于一个main()方法，这个方法必须是公有、返回void、直接受一个字符串数组。在程序执行时，你必须给Java虚拟机指明这个包换main()
jvm的工作原理和特点
playAround的专栏
03-12 1096
【转】来自博客园：朱漪---http://www.cnblogs.com/jiayi/archive/2010/06/08/1753863.html 作为一种阅读的方式了解下jvm的工作原理 JVM工作原理和特点主要是指操作系统装入JVM是通过jdk中Java.exe来完成,通过下面4步来完成JVM环境. 1.创建JVM装载环境和配置 2.装载JVM.dll 3.初始化
jvm装入原理
soleghost的专栏
06-21 1465
jvm装入原理操作系统装入jvm是通过jdk中java.exe来完成,通过下面4步来完成jvm环境.1.创建jvm装载环境和配置2.装载jvm.dll3.初始化jvm.dll并挂界到JNIENV(JNI调用接口)实例 4.调用JNIEnv实例装载并处理class类。在我们运行和调试java程序的时候,经常会提到一个jvm的概念.jvm是java程序运行的环境,但是他同时一个操作系统的一
创建线程的四种方式
最新发布
05-28
在Java中，有以下四种常见的创建线程的方式： 1. 继承Thread类并重写run()方法 ```java public class MyThread extends Thread { @Override public void run() { // 该线程要执行的代码 } } // 启动线程 MyThread thread = new MyThread(); thread.start(); ``` 2. 实现Runnable接口并传入Thread类中 ```java public class MyRunnable implements Runnable { @Override public void run() { // 该线程要执行的代码 } } // 启动线程 MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); ``` 3. 实现Callable接口并传入FutureTask类中 ```java public class MyCallable implements Callable<String> { @Override public String call() throws Exception { // 该线程要执行的代码 return "result"; } } // 启动线程 MyCallable callable = new MyCallable(); FutureTask<String> futureTask = new FutureTask<>(callable); Thread thread = new Thread(futureTask); thread.start(); // 获取线程执行结果 String result = futureTask.get(); ``` 4. 使用线程池创建线程 ```java ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(() -> { // 该线程要执行的代码 }); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值