【多线程基础】创建线程的五种方式、实现多线程数组求和

已于 2024-08-11 22:03:03 修改
阅读量282 收藏 8
点赞数 12
分类专栏： 多线程 文章标签： java-ee 多线程 python
于 2024-08-11 21:17:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75724363/article/details/141112035
版权

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：Java多线程

📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

在这里插入图片描述

在这里插入图片描述

目录

前言

  • 多线程代码
  • 线程，本身是操作系统提供的
  • 操作系统提供了 API 让我们操作线程
  • JVM 就对 操作系统 API 进行了封装
  • 线程这里，提供了 Thread类，表示线程

一、第一个多线程程序

感受多线程和普通线程的区别：

  • 每个线程都是一个独立的执行流
  • 多线程之间是“并发”执行的
import java.util.Random;

public class Test02 {
    private static class MyThread extends Thread{
        @Override
        public void run() {
            Random random = new Random();
            while (true){
                //打印线程名称
                System.out.println(Thread.currentThread().getName());
                try {
                    //随机停止 0 - 9 秒
                    Thread.sleep(random.nextInt(10));
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();

        Random random = new Random();
        while (true){
            //打印线程名称
            System.out.println(Thread.currentThread().getName());
            try {
                //随机停止 0 - 9 秒
                Thread.sleep(random.nextInt(10));
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

接下来看运行结果

在这里插入图片描述

二、使用 jconsole 命令观察线程

能够更清晰看到内部结构

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

三、创建线程的五种写法

@Override注解，相当于是提示编译器，进行更严格的检查。

1.继承 Thread 类

  • 继承 Thread 来创建⼀个线程类
class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("hello thread");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}
  • 创建 MyThread 类的实例
Thread t = new MyThread();
  • 调⽤ start 方法启动线程
t.start();

run方法只是描述了线程要干啥任务

t.start() 调用 操作系统 提供的 “创建线程” api
在内核中创建对应的 pcb ，并把pcb 加入到链表中
进一步的系统调度到这个线程之后，就会执行上述 run 方法中的逻辑

2.实现 Runnable 接口

package thread;

class MyRunnable implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("这里是自己创建的线程的代码");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

public class Demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

上述代码其实有两个线程：
t 线程
main 方法所在的线程（主线程）

在这里插入图片描述

每一秒进行打印的时候，可能 main 在前面，也有可能 自己创建的线程在前面
由此可以看出多个线程的调度顺序，是“无序”的
在操作系统内部也称为“抢占式执行”

3.继承 Thread, 重写 run, 使用匿名内部类

package thread;

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("Thread - 0");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

4.实现 Runnable, 重写 run, 使用匿名内部类

package thread;

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("Thread - 0");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

在这里插入图片描述

5.使用 lambda 表达式

package thread;

public class Demo5 {
    public static void main(String[] args) {
        //比较推荐的写法，匿名内部类的平替
        Thread t = new Thread( () -> {
            while (true){
                System.out.println("Thread - 0");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"我的线程");

        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

在这里插入图片描述

上述五种写法，本质都是
要把线程执行的任务表示出来
通过 Thread 的 start 来创建/启动系统中的线程
Thread 对象和操作系统内核中的线程是一一对应的关系

四、实现多线程数组求和

  1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
  2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
  3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
  4. 最终再汇总两个和, 进行相加
  5. 记录程序的执行时间.
import java.util.Random;

public class Test03 {
    private static final int ARRAY_SIZE = 1000_0000;
    private static final int MAX_VALUE = 100;

    public static void main(String[] args) throws InterruptedException {
        //记录开始的时间
        long start = System.currentTimeMillis();
        //1.给定一个很长的数组（长度为1000w）,通过随机数的方式生成 1-100 之间的整数
        int[] array = new int[ARRAY_SIZE];
        //生成随机数，对数组进行填充
        Random random = new Random();
        for (int i = 0; i < ARRAY_SIZE; i++) {
            array[i] = random.nextInt(MAX_VALUE) + 1;
        }


        //2.创建两个线程 对数组内的元素进行求和
        //3.线程一计算偶数下标元素的和，线程二计算奇数下标元素的和

        //实例化操作类
        SumOperator operator = new SumOperator();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < ARRAY_SIZE; i += 2) {
                operator.addEvenSum(array[i]);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 1; i < ARRAY_SIZE; i += 2) {
                operator.addOddSum(array[i]);
            }
        });

        //启动线程
        t1.start();
        t2.start();

        //等待线程结束
        t1.join();
        t2.join();

        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("计算结果为：" + operator.result());
        System.out.println("总耗时：" + (end - start) + "ms.");
    }
}

class SumOperator{
    long evenSum;//偶数和
    long oddSum;//奇数和

    public void addEvenSum(int num){
        evenSum += num;
    }
    public void addOddSum(int num){
        oddSum += num;
    }
    public long result() {
        System.out.println("偶数和：" + evenSum);
        System.out.println("奇数和：" + oddSum);
        return evenSum + oddSum;
    }
}

在这里插入图片描述

五、利用循环创建多个线程

  • 在子线程执行完毕后再执行主线程代码

  • 有20个线程，需要同时启动。

  • 每个线程按0-19的序号打印，如第一个线程需要打印0

  • 请设计代码，在main主线程中，等待所有子线程执行完后，再打印 ok

public class Test05 {
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[20];
        for (int i = 0; i < 20; i++) {
            final int n = i;
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {//内部类使用外部的变量，必须是final修饰
                    System.out.println(n);
                }
            });
        }
        for (Thread t : threads) {
            t.start();
        }
        for (Thread t : threads) {//同时执行20个线程，再等待所有线程执行完毕
            t.join();
        }
        System.out.println("OK");
    }
}

在这里插入图片描述

六、Thread类中run和start的区别

  • 作用功能不同：

run方法的作用是描述线程具体要执行的任务；
start方法的作用是真正的去申请系统线程

  • 运行结果不同：

run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次；
start调用方法后, start方法内部会调用Java 本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段。

总结

【注意点一】

try - catch:
在实际开发中，里面的内容应该是自己实现的。
例如：

  • 可能会打印一些日志，把出现的异常情况都记录在日志文件中
  • 触发一些重试类的操作
  • 触发一些“回滚”类的操作
  • 触发一些报警机制（给程序员发短信…）

【注意点二】

在main方法中 处理 sleep 既可以使用 throws，也可以使用 try - catch
在线程 run 方法中，只能使用 try - catch
与方法签名有关

【注意点三】

未来实际开发中，发现你负责的服务器程序，消耗 CPU 资源超出预期，应该如何排查这个问题？

  • 首先要先确认，是哪个线程消耗的 CPU 比较高
  • 未来会涉及到一些第三方工具，可以看到每个线程 CPU 消耗情况
  • 确定之后，进一步排查，线程中是否有 “ 非常快速 ” 的循环

在这里插入图片描述

在这里插入图片描述

明志学编程-
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程对数组求和_java面试题-多线程数组求和(CyclicBarrier实现）
weixin_33463850的博客
02-25 289
CyclicBarrier的作用是拦截多个线程，当所有线程到达指定位置时，在开始往下面执行，否则线程等待。两种构造函数：public CyclicBarrier(int parties)public CyclicBarrier(int parties, Runnable barrierAction)其中parties是线程个数，barrierAction是所有线程到达后执行的任务。多线程数组求和，...
java 多线程求和_java多线程面试 - 多线程求和
weixin_42499067的博客
02-13 2901
今天面试过程中碰到一个简单的多线程面试题目，竟然一时钻了牛角尖，没有回答上来，结束面试立刻醒悟过来，想想真丢人。面试题目如下：如何多线程计算 1+2+3+……n，其中n是一个很大的数值，不使用直接的求职公式。因为总是碰到类似于计数器的问题，(多个线程进行计数)，所以思路不自觉的就转到了计数器的处理思路上去了：设置多个线程共享的一个 Integer sum，然后多个线程瓜分 1到n 的整数值，并分别...
实现多线程数组求和.
weixin_48424501的博客
03-28 804
给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和. 最终再汇总两个和, 进行相加 记录程序的执行时间 public class ThreadDemo11 { public static void main(String[] args) throws InterruptedException, ExecutionExce
java多线程之概念和3种创建方式（详解）
快乐学习
09-14 835
一、概念讲解 1.进程和线程的概念 进程：一个执行的应用程序 线程：一个应用程序内的具体执行不同模块 2.进程和进程之间的关系 进程和进程内存独立不共享 3.线程和线程之间的关系 （1）Java中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程 （2） 一个线程一个栈（每个栈之间独立执行，互不干扰，即多线程并发），栈内存独立。堆内存和方法区内存共享 （3）多线程的目的：提高程序的处理效率 （4）单核CPU能做到多线程并发吗：不能(cpu切换处理很快，超过肉眼速度，给人能多线程的假象
多线程实现数组求和
qq_38854914的博客
09-19 1846
多线程实现数组求和 多线程学习 方法1 修改传入线程的数组引用的值，完成后循环累加数组。 public class SumNumber implements Runnable{ private int[] sum; private int formInt; private int intoInt; private int threadNo; public...
Java 多线程加法求和
碳基蒟蒻Serio的博客
04-21 780
使用 Callable 通常结合 FutureTask（实现了 Runnable 和 Future 接口）来包装 Callable 任务，并将其提交给线程池执行，从而可以获得线程执行的结果。Thread 类提供了更多控制线程生命周期的方法，如 start()、join()、interrupt()、setName() 等。包下原子整数类，顾名思义，它所对应整数上发生的操作都是原子性的，线程只能串行的去累加它，就能避免竞态问题。上面的代码中结束线程工作的过程中，涉及到了两个API。Callable 实例。
编写代码, 实现多线程数组求和
weixin_51970219的博客
03-25 1117
编写代码, 实现多线程数组求和 问题： 1.给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数. 2.实现代码, 能够创建两个线程, 对这个数组的所有元素求和. 3.其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和. 4.最终再汇总两个和, 进行相加 5.记录程序的执行时间. 代码: import java.util.Random; import java.util.concurrent.Callable; import java.util.conc
Java----实现多线程数组求和.
m0_56642224的博客
04-01 1447
import java.util.Arrays; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class test { public static void main(String[] args) throws Execution
Java并发和多线程2：3种方式实现数组求和
放眼长期，稳中求进；知行合一，日拱一卒
12-30 9147
本篇演示3个数组求和的例子。例子1：单线程例子2：多线程，同步求和（如果没有计算完成，会阻塞）例子3：多线程，异步求和（先累加已经完成的计算结果）例子1-代码package cn.fansunion.executorservice; public class BasicCaculator { public static long sum(int[] numbers){ long
java线程数组_java面试题-多线程数组求和(CountDownLatch实现）
weixin_36288992的博客
02-20 375
CountDownLatch是一个线程等待其他的所有线程执行完成。先对数组进行分段，每段求和，主线程等待所有线程计算完成之后，在执行整体求和。public class CountDownLatchTest {CountDownLatchTest(int count) {this.count = count;executorService = Executors.newFixedThreadPool...
xiangliang.zip_多核多线程
09-19
在单核处理器时代，多线程主要通过时间片轮转的方式实现并发，而在多核处理器环境下，每个核心可以独立运行一个线程，真正实现并行计算，显著提高处理速度。 向量点积，也称为向量乘法，是线性代数中基本的运算之一...
Java多线程示例，包括错误案例以及正确案例
10-28
Java多线程示例，包括错误案例
C++并发与多线程-运行时选择线程数量
01-20
在构造函数中，我们可以看到一个注释掉的输出语句，它原本会打印出创建线程的ID，这在调试和理解多线程执行流程时非常有用。而在析构函数中，使用了`std::mutex`和`std::lock_guard`来确保在销毁线程时的安全性，...
C#(asp.net)多线程用法示例(可用于同时处理多个任务)
09-02
本示例主要介绍了如何使用`System.Threading.Thread`类来创建和管理多线程，以进行并行计算。 首先，我们需要引入必要的命名空间： ```csharp using System; using System.Collections.Generic; using System.Linq;...
Lab-Aula08:使用线程对 C 中的数组求和
06-09
接下来，让我们深入探讨如何实现数组求和的多线程版本。在单线程程序中，我们通常遍历数组，将所有元素累加到一个变量中。但是，如果数组很大，这可能会耗费较长时间。通过使用多线程，我们可以将数组分成多个部分，...
JavaEE-多线程编程&线程池
2301_78493961的博客
08-05 1157
本篇文章介绍了引入线程池的原因，线程池使用时构造方法中的参数以及面试中常问到拒绝策略，最后利用本篇文章对线程池的理解自行实现的线程池和实现时的注意事项。
【JavaEE】初步认识多线程
2302_79806056的博客
08-08 1072
下面是一些关于线程的关键点：控制流：线程是进程内单一顺序的控制流，每个线程有自己的执行栈和寄存器状态，但共享所属进程的资源，如内存空间、文件句柄和信号。资源共享：在同一进程中，多个线程共享相同的虚拟地址空间、全局变量和其他进程级别的资源，这使得线程间的通信和数据共享比进程间更加高效和简单。独立调度：线程是独立调度和分派的基本单位，这意味着它们可以被操作系统调度来利用CPU时间，从而实现并行或并发执行。类型：
【JavaEE初阶】文件操作和IO
最新发布
2301_81510374的博客
08-10 510
我们先来看看 File 类中的常见属性、构造方法和方法。
JavaEE 第7节 线程饥饿及其解决办法
2301_80636143的博客
08-08 767
线程饥饿）指的是多线程中，某些线程无法获得相关资源或者执行机会（阻塞，BLOCKED）长时间如此对线程的推进和响应造成明显影响的现象左边的蘑菇头和右边的小人都是线程，左边的蘑菇头因为在所中没有自己想要的资源所以从锁中出来，但是由于它的优先级比较高一从锁里出来，转头有跑进锁里面了，完全没有给右边的小进去的机会。当饥饿到一定程度，赋予线程的任务即使完成也不在具有实际意义的时候就说明这个线程被饿死了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值