Java中同时启动多个线程并传入不同参数

最新推荐文章于 2024-07-27 04:46:44 发布
原创 最新推荐文章于 2024-07-27 04:46:44 发布 · 2.4k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程

这篇博客介绍了在Java中如何同时启动多个线程并传入不同参数，通过两种方法实现：一是结合threadLocal和CountDownLatch，二是直接传入不同的对象实例。文章详细讲解了threadLocal的原理和CountDownLatch的使用，并提供了实践代码示例。

最近在写多线程测试程序的时候遇到了一些问题，根据参考及自己实践，做记录如下

Java中同时启动多个线程并传入不同参数

threadLocal原理及说明参考

threadLocal

Java中同时启动多个线程(CountDownLatch)

同时启动多个线程

Java向线程传入参数

Java向线程传入参数的三种方法
可以通过构造器或者set的方式，或者回调函数传入

同时启动多个线程并传入不同的参数（自己练习）

方式一：使用threadLocal+CountDownLatch
  1. threadLocal用于存储线程的局部变量，不同的线程启动后存入线程各自的参数，然后去获取。
  2. CountDownLatch用于控制线程同时启动
public class Test {
  ThreadLocal<String> threadLocal=new ThreadLocal<String>();
  @Test
  public void findOrderSplitDetailsTest() throws InterruptedException {
      QueryOrderByPayReqVo reqVo=new QueryOrderByPayReqVo();
      reqVo.setOrderId("56290014401");
      orderQueryResource.findOrderSplitDetails(reqVo);
      Thread.sleep(1000L);
      CreateOrderReqVo reqVo1=new CreateOrderReqVo();
      reqVo1.setPayMode(2);
      reqVo1.setParentOrderId("56290014401");
      reqVo1.setOrderId("56308748910");
      CountDownLatch countDownLatch = new CountDownLatch(3);

      for (int i=0; i<3; i++) {
      //本意是这样实现给不同的线程传入不同的参数，然后因为reqVo是myThread1中的成员变量，不是run方法中的局部变量，所以是不对的
          /*if(i==1){
              reqVo1.setOrderId("56308748911");
          }else if(i==2){
              reqVo1.setOrderId("56308748912");
          }*/
          Thread thread = new Thread(new myThread1(reqVo1,countDownLatch));
          thread.setName("线程-" + (i+1));
          thread.start();
          countDownLatch.countDown();
      }
      Thread.sleep(1000L);
  }


  public class myThread1 implements Runnable{
      CreateOrderReqVo reqVo;
      private final CountDownLatch countDownLatch;
      public myThread1(CreateOrderReqVo reqVo,CountDownLatch   countDownLatch){
          this.reqVo=reqVo;
          this.countDownLatch=countDownLatch;
      }
      @SneakyThrows
      @Override
      public void run() {
          try{
              countDownLatch.await();
              if(Thread.currentThread().getName().endsWith("1")){
                  threadLocal.set("1111111");
              }else if(Thread.currentThread().getName().endsWith("2")){
                  threadLocal.set("222222");
              }else{
                  threadLocal.set("3333333");
              }
              System.out.println("线程"+Thread.currentThread().getName()+"  开始执行");
              System.out.println("查询父子单："+threadLocal.get());
              isReceiveVirtualPay(reqVo);
          }catch (InterruptedException e){
              e.printStackTrace();
          }

      }
   }
   
//isReceiveVirtualPay(reqVo);也是本类中的方法，其可以调用threadLocal.get()输出当前执行改方法的线程的threadLocal存储变量

    private void isReceiveVirtualPay(CreateOrderReqVo reqVo) {
       System.out.println("我是子单："+threadLocal.get());
    }
}

输出：

线程线程-2  开始执行
线程线程-3  开始执行
查询父子单：3333333
线程线程-1  开始执行
查询父子单：1111111
查询父子单：222222
我是子单：1111111
我是子单：3333333
我是子单：222222
方式二：给线程传入不同的对象实例
  1. 方式一用threadlocal存储线程局部变量，方式二直接传入新的变量
  2. 注意点在于每次传入的变量或实例都必须是新的
public class Test {
  @Test
  public void findOrderSplitDetailsTest() throws InterruptedException {
      QueryOrderByPayReqVo reqVo=new QueryOrderByPayReqVo();
      reqVo.setOrderId("56290014401");
      orderQueryResource.findOrderSplitDetails(reqVo);
      Thread.sleep(1000L);
       final CreateOrderReqVo reqVo1=new CreateOrderReqVo();
        reqVo1.setPayMode(2);
        reqVo1.setParentOrderId("56307822401");
        reqVo1.setOrderId("56308748910");
        final CreateOrderReqVo reqVo2=new CreateOrderReqVo();
        reqVo2.setPayMode(2);
        reqVo2.setParentOrderId("56307822401");
        reqVo2.setOrderId("56308748911");
        final CreateOrderReqVo reqVo3=new CreateOrderReqVo();
        reqVo3.setPayMode(2);
        reqVo3.setParentOrderId("56307822401");
        reqVo3.setOrderId("56308748912");
        CountDownLatch countDownLatch = new CountDownLatch(3);
        for (int i=0; i<3; i++) {
            Thread thread=null;
            if(i==1){
                thread=new Thread(new myThread1(reqVo2,countDownLatch));
            }else if(i==2){
                thread=new Thread(new myThread1(reqVo3,countDownLatch));
            }else{
                thread=new Thread(new myThread1(reqVo1,countDownLatch));
            }
            thread.setName("线程-" + (i+1));
            thread.start();
            countDownLatch.countDown();
        }
        Thread.sleep(1000L);
  }


  public class myThread1 implements Runnable{
      CreateOrderReqVo reqVo;
      private final CountDownLatch countDownLatch;
      public myThread1(CreateOrderReqVo reqVo,CountDownLatch   countDownLatch){
          this.reqVo=reqVo;
          this.countDownLatch=countDownLatch;
      }
      @SneakyThrows
      @Override
      public void run() {
          try{
              countDownLatch.await();
              System.out.println("线程"+Thread.currentThread().getName()+"  开始执行");
              System.out.println("查询父子单："+reqVo.getOrderId());
              isReceiveVirtualPay(reqVo);
          }catch (InterruptedException e){
              e.printStackTrace();
          }

      }
   }
   
//isReceiveVirtualPay(reqVo);也是本类中的方法，这里每个线程传入的都是新的CreateOrderReqVo对象，所以是不同的

    private void isReceiveVirtualPay(CreateOrderReqVo reqVo) {
       System.out.println("我是子单："+reqVo.getOrderId());
    }
}

输出：

线程线程-2  开始执行
查询父子单：56308748911
线程线程-3  开始执行
查询父子单：56308748912
线程线程-1  开始执行
查询父子单：56308748910
我是子单：56308748910
我是子单：56308748911
我是子单：56308748912
  1. 另外方式二也可以这样写，结果是一样的
public class Test {
  @Test
  public void findOrderSplitDetailsTest() throws InterruptedException {
      QueryOrderByPayReqVo reqVo=new QueryOrderByPayReqVo();
      reqVo.setOrderId("56290014401");
      orderQueryResource.findOrderSplitDetails(reqVo);
      Thread.sleep(1000L);
      final CreateOrderReqVo reqVo2=new CreateOrderReqVo();
      reqVo2.setPayMode(2);
      reqVo2.setParentOrderId("56307822401");
      reqVo2.setOrderId("56308748911");
      final CreateOrderReqVo reqVo3=new CreateOrderReqVo();
      reqVo3.setPayMode(2);
      reqVo3.setParentOrderId("56307822401");
      reqVo3.setOrderId("56308748912");
      CountDownLatch countDownLatch = new CountDownLatch(3);
//相关与每次启动线程中时候给线程传入不同的对象（对象必须是新new的）
      for (int i=0; i<3; i++) {
            if(i==1){
                threadEx(reqVo2,i,countDownLatch);
            }else if(i==2){
                threadEx(reqVo3,i,countDownLatch);
            }else{
                threadEx(reqVo1,i,countDownLatch);
            }
            countDownLatch.countDown();
        }
        Thread.sleep(1000L);
  }

   public void threadEx(final CreateOrderReqVo reqVo, int i, final CountDownLatch countDownLatch){
        new Thread(new Runnable(){

            @SneakyThrows
            @Override
            public void run() {
                countDownLatch.await();
                System.out.println("线程"+Thread.currentThread().getName()+"  开始执行");
                System.out.println("查询父子单："+reqVo.getOrderId());
                isReceiveVirtualPay(reqVo);
            }
        },"线程-" + (i+1)).start();
    }
   
//isReceiveVirtualPay(reqVo);也是本类中的方法，这里每个线程传入的都是新的CreateOrderReqVo对象，所以是不同的

    private void isReceiveVirtualPay(CreateOrderReqVo reqVo) {
       System.out.println("我是子单："+reqVo.getOrderId());
    }
}
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
最新发布
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
java多线程编程之从线程返回数据的两种方法
09-04
Java多线程编程中，从线程返回数据是并发编程中的常见需求，通常有以下两种主要方法：通过类成员变量和方法返回数据，以及通过回调函数返回数据。 ### 一、通过类成员变量和方法返回数据 这种方法的核心是利用线程...
Java多线程初学者指南（7）：向线程传递数据的三种方法
死牛胖子的技术随笔
11-16 1385
在传统的同步开发模式下，当我们调用一个函数时，通过这个函数的参数将数据传入，并通过这个函数的返回值来返回最终的计算结果。但在多线程的异步开发模式下，数据的传递和返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据。本文就以上原因介绍了几种用于向线程传递数据的方法，在下一篇文章中将介绍从线程中返回数据的方法...
java向多线程中传递参数的三种方法详细介绍
09-05
但在多线程的异步开发模式下，数据的传递和返回和同步开发模式有很大的区别。由于线程的运行和结束是不可预料的，因此，在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据
python线程池传递多个参数示例
weixin_54506550的博客
05-18 1893
这段时间的工作中频繁使用线程池，而任务函数需要传递多个参数;在之前的认知中，线程池都只能传递一个参数，参数可以是。这个代码中，任务列表中的每一个元组表示一个任务函数的实参元组，正常直接进行传递是无法传递给任务函数的，所以这里通过。这个问题困扰了我很久，今天偶然间看到一位佬的文章，学习到了一种传递多个参数的方法。函数对元组进行解包，这样就可以把多个参数传递到任务函数了。这种用法只能传递一个参数，如果任务函数有多个参数时就会。
java多线程：向线程传递参数的方法
Growing_hacker的博客
12-24 2259
同步开发下，我们调用一个函数的时候，通过函数的入参方式进行传入，函数的rerurn返回获取的结果； 然而多线程的异步开发下，由于线程的运行和结束是不可预料的，导致数据的传递和返回有所不同。 多线程传递参数方法一：利用构造方法 多线程传递参数方法二：利用实例方法 多线程传递参数方法三：利用回调方法 ===> 另一篇：java回调方法介绍 ...
java多线程传参数
qq_34631220的博客
01-17 530
【代码】java多线程传参数。
java多线程读取多个文件的方法
08-25
其次，本文使用了`CountDownLatch`这一同步辅助类，它可以用来使一个或多个线程等待其他线程完成操作。`CountDownLatch`的构造函数中传入一个整数（计数器），表示需要等待的事件数量。线程在调用`await()`方法后，...
Java向Runnable线程传递参数方法实例解析
08-19
在Java中，Runnable接口是实现多线程的关键，通过实现Runnable接口的run()方法，可以创建一个线程并执行相应的任务。然而，在实际开发中，我们经常需要将数据传递给Runnable线程，以便在线程中执行相应的任务。那么...
java向多线程中传递参数
代码，问题记录
06-13 1635
1：通过构造方法传递参数 public class MyThread1 extends Thread  {            private String name;            public MyThread1(String name) //构造方法          {                     this.name = name;           
Java多线程参数如何传递
半亩方塘立身
01-10 3604
在多线程编程中，共享数据可能导致一系列的问题，如数据竞争和线程安全性问题。ThreadLocal：不会传递threadLocal副本到子线程中。 InheritableThreadLocal：在子线程创建的时候，父线程会把threadLocal拷贝到子线中。 TransmittableThreadLocal：解决了InheritableThreadLocal中线程池复用线程时，变量传递的问题
JAVA多线程学习笔记<3>线程传入参数与终止线程方法
Life is Float.
05-10 1375
public class TimeThread extends Thread { private long start; public volatile boolean exit = false; public TimeThread(long start) { this.start = start; } public void run() { while(!exit
启动线程，向线程传递参数
anna2117的博客
09-06 1103
线程执行完入口函数，也会退出，在为一个线程创建一个std::thread对象后，需要等待这个线程结束。 线程在std::thread对象创建时启动 构造std::thread对象，std::thread可以用可调用类型来构造： std::thread mythread(f) //会用f的构造函数去初始化mythread，替换默认的构造函数 std::thread mythread{f} ...
Python多线程运行带多个参数的函数
Python热爱者的博客
02-18 1685
在python中经常会到用多线程处理某个函数来缩短运行时间。 from multiprocessing import Pool def work(x): return x+1 pool = Pool(processes=4) # 4个线程 x = [1,2,3,4,5,6] results = pool.map(work, x) print (results) 运行上面的程序就会多线程处理并打印出输入x的计算结果。 但是这个函数仅允许函数的输入变量为1，如果函数需要多个参数输入，那个就无法用上面
java 异步线程参数传递
weixin_31832223的博客
07-27 406
Java 异步线程参数传递 在现代软件开发中，多线程编程是一种常见的做法，特别是在需要处理大量并发任务时。Java 提供了多种方式来实现多线程，包括继承 Thread 类和实现 Runnable 接口。然而，当涉及到异步线程时，参数传递可能会变得复杂。本文将介绍如何在 Java 中实现异步线程的参数传递，并提供代码示例。 ...
Java 多线程传值有三种方式，以及另类的第四种方式
kevon_sun的专栏
06-16 2763
其实大家都知道多线程传值有三种方式：1：通过构造方法传递数据 2：通过变量和方法传递数据 3：通过回调函数传递数据那么博主有个非常变态的需求，所以找出了第四种实现方式，先看效果图：动态Cron4j调度器，我曾经发过类似的文章，可以去搜索一下.点击执行走下边的代码，然后根据类名反编译public static void executeCron4j(String packageClass){     ...
Java多个线程访问同个方法_在Java中使用多线程调用同一类的不同方法
weixin_34098296的博客
02-24 2981
我有以下三种方法的课程public class MyRunnable implements Runnable {@Overridepublic void run() {// what code need to write here//to call the specific methods based on request types}public int add(int a, int b){re...
Java方法中不同参数的传递
sugar_hang的博客
09-13 1726
1.将基本数据类型传递给方法 调用方法的时候是通过传值的方式将实参传递给形参。 当调用带参数的方法时，实参的值传递给形参，这个过程称为按值传递。如果实参是变量而不是直接量，则将该变量的值传递给形参。无论形参在方法中是否改变，该变量都不受影响。如下边代码所示，x(1)的值传给参数n，用以调用方法increment。在该方法中n自增1，而x的值则不论方法做了什么都保持不变。 public class text1 { public static void main...
JAVA多线程编程：启动线程的正确姿势
在Java编程语言中，线程的创建和管理是并发编程的基础。线程是程序中能够独立执行的最小调度单元，它可以让程序...这是初学者进入Java多线程编程的典型示例，通过这样的例子，可以快速学习和理解线程的创建和启动过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值