Java多线程01——多线程的创建

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量184 收藏 1
点赞数
分类专栏： java 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ156881887/article/details/128908488
版权
本文详细介绍了Java中创建线程的五种方式，包括继承Thread类、实现Runnable接口、实现Callable接口、使用TimerTask以及通过线程池启动线程。每种方式都有其特点，如线程间的资源共享、带返回值的线程以及线程池带来的性能优化。
摘要由CSDN通过智能技术生成

1 进程和线程

进程：

  • 进程是并发执行程序在执行过程中，资源分配和管理的基本单位。

  • 进程可以理解为一个应用程序的执行过程，应用程序一旦执行，就是一个进程。

线程：

  • 线程是进程的一个执行单元，是进程内可调度实体。

  • 线程是比进程更小的独立运行的基本单位。

  • 线程也被称为轻量级进程。

二者的区别：

名称进程线程
地址空间不同的进程之间的地址空间是独立的同一进程的所有线程共享本进程的地址空间
资源拥有进程之间的资源是独立的，无法共享同一进程的所有线程共享本进程的资源
执行过程每一个进程可以说就是一个可执行的应用程序线程不能够独立执行，必须依存在应用程序中

2 创建线程的五种方式

 

2.1 继承 Thread 类

通过继承Thread并且重写其run()方法，run()方法中定义需要执行的任务。

创建后的子类通过调用start()方法即可执行线程方法。

注意： 通过继承Thread创建的线程类，多个线程间无法共享线程类的实例变量。 需要创建不同Thread对象，自然不共享资源。

/*
定义线程类，继承Thread
重写run()方法
创建线程类对象
调用start()方法启动线程
*/
public class UserThread extends Thread {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName() + " is running " + i);
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        for(int i=0;i<2;i++){
            new UserThread().start();
        }
    }
}
复制代码

输出如下：

Thread-0 is running 0

Thread-1 is running 0

Thread-1 is running 1

Thread-1 is running 2

Thread-0 is running 1

Thread-0 is running 2

2.2 实现 Runnable 接口

需要先定义一个类实现 Runnable 接口并重写该接口的 run() 方法，此run()方法是线程执行体。

接着创建Runnable实现类的对象，作为创建Thread对象的参数target，此Thread对象才是真正的线程对象。

利用实现Runnable接口的线程类创建对象，可以实现线程之间的资源共享。

/*
定义线程类，实现 Runnable接口
重写run()方法
创建实现类对象
创建Thread类，并将线程类对象参数传入Thread构造方法中
启动线程
*/
public class UserRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++) {
            System.out.println(Thread.currentThread().getName() + " is running" + i);
        }
    }
}
public class TestUserRunnable {
    public static void main(String[] args) {
        UserRunnable userRunnable = new UserRunnable();
        new Thread(userRunnable).start();
        new Thread(userRunnable).start();
    }
}
复制代码

输出如下：

Thread-0 is running 0

Thread-1 is running 0

Thread-1 is running 1

Thread-1 is running 2

Thread-0 is running 1

Thread-0 is running 2

2.3 实现 Callable 接口实现带有返回值的线程

Callable 接口如同 Runnable 接口的升级版，其提供的 call() 方法将作为线程的执行体，同时允许有返回值。

Callable 对象不能直接作为 Thread 对象的target，因为 Callable 接口是 Java5 新增接口，不是 Runnable 接口的子接口。

对于这个问题的解决方案，就引入 Future 接口，此接口可以接受 call() 的返回值，RunnableFuture 接口是 Future 接口和 Runnable 接口的子接口，可以作为 Thread 对象的target。

import java.util.concurrent.Callable;

/**
 * 定义线程类UserCallable，实现Callable接口
 * 重写call()方法
 * 创建UserCallable对象
 * 创建 FutureTask（实现了接口 RunnableFuture） 的对象，构造函数的参数是 UserCallable 的对象
 * 创建 Thread 对象，构造函数的参数是 FutureTask 对象
 * 启动线程
 */
public class UserCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " 启动！");
        return "我重写了call方法";
    }
}

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

public class TestUserCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        UserCallable userCallable = new UserCallable();
        FutureTask futureTask = new FutureTask(userCallable);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}
复制代码

输出如下：

Thread-0 启动！

我重写了call方法

2.4 继承 TimerTask

Timer 和 TimerTask 可以作为实现线程的另一种方式。

Timer 是一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行，可以看成一个定时器，可以调度 TimerTask。

TimerTask 是一个抽象类，实现了 Runnable 接口，所以具备了多线程的能力。

多线程类

import java.util.Date;
import java.util.TimerTask;

/**
 * 创建 UserTimer 类，继承 TimerTask 抽象类
 * 创建 UserTimer 对象
 * 创建 Timer 类对象，设置任务的执行策略
 */
public class UserTimer extends TimerTask {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running " + new Date());
    }
}
复制代码

测试类

import java.util.Timer;

public class TestUserTimer {
    public static void main(String[] args) {
        UserTimer userTimer = new UserTimer();
        Timer timer = new Timer();
        timer.schedule(userTimer, 3000, 2000);
    }
}
复制代码

输出如下：

Timer-0 is running Sat Sep 18 23:10:47 CST 2021

Timer-0 is running Sat Sep 18 23:10:49 CST 2021

Timer-0 is running Sat Sep 18 23:10:51 CST 2021

Timer-0 is running Sat Sep 18 23:10:53 CST 2021

Timer-0 is running Sat Sep 18 23:10:55 CST 2021

Timer-0 is running Sat Sep 18 23:10:57 CST 2021

2.5 通过线程池启动多线程

通过 Executors 的工具类可以创建线程池。

提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行。

降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗。

方便线程并发数的管控，因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM（内存溢出），并且会造成CPU过度切换。

2.5.1 线程池一：固定大小的线程池FixThreadPool(int n)

创建有固定线程数的线程池

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

public class FixThreadPoolTest {
    public static void main(String[] args) {
        //创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //使用线程池执行任务
        for(int i=0;i<5;i++){
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for(int j=0;j<3;j++){
                        System.out.println(Thread.currentThread().getName() + " : " + j);
                    }
                }
            });
        }

        executorService.shutdown();
    }
}
复制代码

输出如下：

pool-1-thread-1 : 0

pool-1-thread-2 : 0

pool-1-thread-2 : 1

pool-1-thread-2 : 2

pool-1-thread-1 : 1

pool-1-thread-3 : 0

pool-1-thread-3 : 1

pool-1-thread-3 : 2

pool-1-thread-2 : 0

pool-1-thread-2 : 1

pool-1-thread-1 : 2

pool-1-thread-2 : 2

pool-1-thread-3 : 0

pool-1-thread-3 : 1

pool-1-thread-3 : 2

2.5.2 线程池二：单线程池 SingleThreadPoolExecutor

单线程串行执行任务，确保任务按提交顺序执行；

当线程异常结束后，会有新的线程代替之前的线程。

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

public class SingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        for(int i=0;i<3;i++){
            es.submit(new Runnable() {
                @Override
                public void run() {
                    for(int j=0;j<3;j++){
                        System.out.println(Thread.currentThread().getName() + " : " + j);
                    }
                }
            });
        }
        es.shutdown();
    }
}
复制代码

输出如下：

pool-1-thread-1 : 0

pool-1-thread-1 : 1

pool-1-thread-1 : 2

pool-1-thread-1 : 0

pool-1-thread-1 : 1

pool-1-thread-1 : 2

pool-1-thread-1 : 0

pool-1-thread-1 : 1

pool-1-thread-1 : 2

2.5.3 线程池三：缓存线程池 CachedThreadPool()

线程池数量不固定，可以达到最大值。

线程可被重复利用和回收。

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

public class CachedThreadExecutor {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        for(int i=0;i<5;i++){
            es.submit(new Runnable() {
                @Override
                public void run() {
                    for(int j=0;j<3;j++){
                        System.out.println(Thread.currentThread().getName() + " : " + j);
                    }
                }
            });
        }
        es.shutdown();
    }
}
复制代码

输出如下：

pool-1-thread-2 : 0

pool-1-thread-2 : 1

pool-1-thread-2 : 2

pool-1-thread-5 : 0

pool-1-thread-5 : 1

pool-1-thread-5 : 2

pool-1-thread-4 : 0

pool-1-thread-4 : 1

pool-1-thread-4 : 2

pool-1-thread-3 : 0

pool-1-thread-3 : 1

pool-1-thread-1 : 0

pool-1-thread-1 : 1

pool-1-thread-1 : 2

pool-1-thread-3 : 2

2.5.4 线程池四：周期性的线程池 newScheduledThreadPool()

创建一个周期性的线程池，支持定时及周期性执行任务

创建线程时，指定核心线程数，当执行任务较多超过核心线程时，可额外启动新的线程；

当任务恢复后，仅保留核心线程，其它额外线程将被关闭。

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadTest {
    public static void main(String[] args) {
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        ses.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 执行 " + new Date());
            }
        }, 5, 3, TimeUnit.SECONDS);
    }
}
复制代码

输出如下：

pool-1-thread-1 执行 Sun Sep 19 00:58:55 CST 2021

pool-1-thread-1 执行 Sun Sep 19 00:58:58 CST 2021

pool-1-thread-2 执行 Sun Sep 19 00:59:01 CST 2021

pool-1-thread-1 执行 Sun Sep 19 00:59:04 CST 2021

pool-1-thread-3 执行 Sun Sep 19 00:59:07 CST 2021

pool-1-thread-3 执行 Sun Sep 19 00:59:10 CST 2021

2.5.5 线程池五：新的线程池类 ForkJoinPool 的扩展 newWorkStealingPool

JDK1.8增加， 任务窃取线程池，线程有属于自己的队列，更加适用于多核心处理器。

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

public class WorkStealingPoolTest {
    public static void main(String[] args) {
        ExecutorService es = Executors.newWorkStealingPool();
        for(int i=0;i<10;i++){
            es.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("---END----");
    }
}
复制代码

输出如下：

ForkJoinPool-1-worker-1

ForkJoinPool-1-worker-1

ForkJoinPool-1-worker-1

ForkJoinPool-1-worker-2

ForkJoinPool-1-worker-3

ForkJoinPool-1-worker-3

ForkJoinPool-1-worker-3

ForkJoinPool-1-worker-3

ForkJoinPool-1-worker-2

ForkJoinPool-1-worker-1

---END----

java创建多线程的四种方式
weixin_48016395的博客
02-15 4766
java多线程的创建方式是面试经常会被问到的一个问题，因此在这里我对java创建多线程的四种方式做一个简单的归纳与总结，便于复习。 一、继承Thread类创建多线程 ① 创建一个继承于Thread类的子类。 ② 重写Thread类中的run()方法，在run()方法中实现线程需要完成的功能。 ③ 创建Thread类的子类的对象，并调用这个对象的start()方法，调用start()后会自动启动当前线程，并调用当前线程的run()方法。 ...
Java多线程(头歌)
m0_74304371的博客
12-06 2236
Java多线程(头歌) 代码
多线程的创建
遇安的博客
04-23 2741
创建方式一：继承Thread类创建多线程 public class 多线程_1创建 { public static void main(String[] args) { //创建方式一 Thread t=new MyThread();//创建MyThread线程对象 //直接调run()方法会被当成普通方法执行，此时相当于还是单线程执行， // 所以需要调用start()方法启动多线程 t.start();//调.
JAVA高级基础（71）---Executor执行Runnable任务
11onhook的博客
01-19 996
Executor框架：支持并发编程的线程池 Executors 1、ExecutorService    newFixedThreadPool(int initThread) 在线程池中，创建固定数目的线程。当执行任务的时候，如果线程池中由空闲线程，则直接使用该线程来执行任务，如果没有空闲线程，则任务处于阻塞状态，等待线程空闲。 2、ExecutorService    newCacheT...
使用线程池和直接new 一个Thread运行对比
热门推荐
小白杨
05-13 1万+
大家new Thread的方式会创建一个线程，在我们有大量的创建线程的时候这样的方法还会可靠吗？每一次new Thread都会重新创建一个线程，而线程的创建和销毁都需要耗时的。在jdk1.5的concurrent包中有一个Executors，他能使我们创建的线程得到复用，不会频繁的创建和销毁线程。 在网上已经有很多博文介绍了Executors了，我们今天主要是我们使用了Executors和每次n
java多线程 ———— 线程停止
向来缘浅，奈何情深
04-05 1491
1、线程的停止方法 我们在之前的博客提到过，线程怎么创建。 线程池：https://blog.csdn.net/jjs15259655776/article/details/105037208 创建和启动线程：https://blog.csdn.net/jjs15259655776/article/details/84350022 这次我们主要介绍怎么停止线程。主要有两种方法： 调用st...
Java多线程系列——-多线程的风险问题
01-08
这篇文章，我想说明一下关于Java多线程中会遇到的几种风险以及它们的 概念 1.死锁: 死锁的含义是指一组线程在执行过程中竞争资源导致的一种阻塞的现象，其原因是其中的每一个线程都在等待仅由该组中其他线程才可以...
Java多线程运用——模拟接力赛
Alcaibur的博客
11-13 780
运用Thread和Runnable的两种线程，模拟接力赛。
Java多线程——之一创建线程的四种方法
08-26
Java多线程——之一创建线程的四种方法 Java多线程是Java编程语言中的一种重要概念，它允许程序同时执行多个任务，以提高程序的执行效率和响应速度。创建线程是Java多线程编程的基础，Java提供了四种创建线程的方法...
java多线程案例——未完成
08-21
Java多线程是Java编程中的一个重要领域，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是...
线程池——Runnable、Callable
weixin_42022555的博客
08-14 425
线程池：顾名思义就是一个装了许多线程的池子 主要用来创建和管理线程对象的容器（达到线程复用的效果） 好处： 1.减少资源的消耗，避免频繁的创建和销毁线程 2.提高程序的响应速度 3.提高线程的可管理性   创建线程池对象，需要使用Executors工具类的方法 public static ExecutorService newFixedThreadPool(int nThreads...
线程学习二：线程池执行Runnable与Callable
人有匪气，代码才能飞起
10-14 2648
1、了解线程池几个类之间的关系 （结合图看后面的分析）             FutureTask  继承 RunnableFuture , RunnableFuture 实现接口 Runnable 2、分析常用调用线程池代码（以下称为代码A）       Executo
Java并发学习笔记(一)-Runnable和Executor
ltnb的专栏
12-20 3142
并发通常是为了提高运行在单处理器上的程序的性能。在单处理器上，表面上看，并发程序往往由于增加了上下文切换导致程序CPU开销大，程序以单线程顺序执行开销会小一点，节省上下文切换的代价。 那么为什么要在单处理器上使用并发呢？有以下两个原因： 阻塞。程序的某个任务由于某些条件（一般是I/O），导致不能继续执行，那么这个任务或者线程阻塞了。单线程情况下，整个程序都将停下来，直到条件成熟。如果使
JAVA-01-变量
LJH_laura_li的博客
11-08 261
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 134
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 488
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 317
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 989
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
Java多线程基础：创建与概念模型详解
这个PPT主要介绍了Java多线程的基础，包括创建线程的基本步骤和线程概念模型，为后续深入学习线程并发编程打下基础。如果你需要深入了解Java多线程的高级特性，如并发容器、Future和Callable接口、Executor框架等，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我有健康

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值