java多线程累加计数的实现方法

 更新时间:2021年05月20日 11:00:44   作者:安迪爸爸  
在多线程协作任务中,如何计算也是很重的,这篇文章主要介绍了java多线程累加计数的实现方法,感兴趣的朋友可以了解一下

题目

给定count=0;让5个线程并发累加到1000;

思路

  • 创建一个类MyRunnable,实现Runnable(继承Thread类也可)
  • 定义一个公共变量count(初始值为0),5个线程都可以访问到;
  • 创建5个线程并发递增count到1000;

注意

这块注意Thread和Runnable类的区别,Thread类是线程类,可以直接new Thread().start运行。而Runnable类是任务类,需要一个线程来承载任务,通过new Thread(new Runnable()).start()来运行任务。

方法

方法一

将count公共变量放到测试类Test的类成员变量里,将MyRunnable类作为Test类的内部类,在Test类的main方法里创建5个线程,实现累加。

代码

public class Test {
 //公共变量
 int count=0;
 public static void main(String[] args){
  //new一个实现Runnable的类
  Test test=new Test();
  //创建5个任务
  MyRunnable myRunnable1=test.new MyRunnable();
  MyRunnable myRunnable2=test.new MyRunnable();
  MyRunnable myRunnable3=test.new MyRunnable();
  MyRunnable myRunnable4=test.new MyRunnable();
  MyRunnable myRunnable5=test.new MyRunnable();
  //创建5个线程
  new Thread(myRunnable1).start();
  new Thread(myRunnable2).start();
  new Thread(myRunnable3).start();
  new Thread(myRunnable4).start();
  new Thread(myRunnable5).start();
 }
 //创建一个实现Runnable的类
 class MyRunnable implements Runnable{
  public void run() {
   while(true){
    //锁住的是整个MyRunnable类
    synchronized(MyRunnable.class){
     if(count>=1000){
      break;
     }
     System.out.println(Thread.currentThread().getName()+":count:"+(++count));
     //测试时,线程更容易切换
     Thread.yield();
    }    
   }
  }  
 } 
}

方法二
以上代码没有问题,成功实现5个线程累加count到1000,接下来我们将上边代码稍作修改。

  • 将5个线程执行5个任务,修改为5个线程执行同一任务。
  • 将synchronized(MyRunnable.class)修改为synchronized(this)

代码

public class Test {
 //公共变量
 int count=0;
 public static void main(String[] args){
  //new一个实现Runnable的类
  Test test=new Test();
  //创建1个任务
  MyRunnable myRunnable1=test.new MyRunnable();
//  MyRunnable myRunnable2=test.new MyRunnable();
//  MyRunnable myRunnable3=test.new MyRunnable();
//  MyRunnable myRunnable4=test.new MyRunnable();
//  MyRunnable myRunnable5=test.new MyRunnable();
  //创建5个线程
  for(int i=0;i<4;i++){
   new Thread(myRunnable1).start();
  }
//  new Thread(myRunnable2).start();
//  new Thread(myRunnable3).start();
//  new Thread(myRunnable4).start();
//  new Thread(myRunnable5).start();
 }
 //创建一个实现Runnable的类
 class MyRunnable implements Runnable{
  public void run() {
   while(true){
    //锁住的是同一对象
    synchronized(this){
     if(count>=1000){
      break;
     }
     System.out.println(Thread.currentThread().getName()+":count:"+(++count));
     //测试时,线程更容易切换
     Thread.yield();
    }
    
   }
  }  
 }
}

以上代码没有问题,成功实现5个线程累加count到1000。 

虽然结果是一样的,但是代码实现是不一样的,代码一是创建了5个MyRunnable对象,代码二只创建了1个MyRunnable对象。考虑并发时用到的锁就是不一样的,

代码一和代码二虽然synchronized中的锁不同,但目的都是为了括号中的锁是恒定不变的。

  • synchronized(this)代表锁是this对象,代码二中之所以可以使用this,是因为几个线程使用的this都是同一个对象。
  • synchronized(MyRunnable.class)代表锁是MyRunnable.class.this,因为MyRunnable.class.this是类加载到静态方法区中,是一直存在不变的,代码一中可以使用,当然代码二也可以这样写。
  • 代码一和代码二可以使用更通用的方式就是专门new一个锁对象,这个锁对象可以放在类成员变量里,加上static就可以一直常存。如定义成public static Object lock=new Object();代码一和代码二都可以使用synchronized(lock)来加锁。synchronized(this)这种方式主要是因为书写方便。

方法三

使用AtomicInteger类,来实现多线程累加,AtomicInteger类是线程安全的,使用它的优点就是我们不需要在代码里写Synchronized关键字了,这些事都交给它去做了。

代码

public class Test {
    static CountDownLatch cdl=new CountDownLatch(1000);;
    static AtomicInteger ai=new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException{ 
     ExecutorService exec=Executors.newFixedThreadPool(100);
       for (int i = 0; i < 1000; i++) {
        exec.execute(new Runnable() {
    @Override
    public void run() {
     System.out.println(Thread.currentThread().getName()+":"+ai.getAndIncrement());
     cdl.countDown();
    }
   });
          }
     cdl.await();
     System.out.println(ai.get());
     exec.shutdown();
    } 
}

代码中用到了CountDownLatch类,用法就是给其设定一个初始值1000,然后在不同线程中执行countDown方法,每执行一次,初始值-1,await方法就是等初始值减到0时,停止等待,否则一直等待。

我在代码里新建了100个线程来并发累加,让我们看下最后结果。

控制台输出如下:

可以看到虽然输出不是按照顺序输出的,但是最后的结果是我们想要的结果,没有出现重复值的情况。

总结

这到题目只是举了一个多线程的例子,以及锁的简单知识。在实际应用中,从0累加到1000用多线程是没有意义的。因为根本不会比单线程快。就像让一个人数数,从0数到1000,或者让5个人接替数到1000,应该一个人更快点吧,5个人还要考虑配合的问题。但假如这5个人都是磕巴(口语不好),一个人每读一个数都要停顿1秒,但是让5个人协作,省去中间的等待时间,才是多线程应用的真正意义。
多线程的真正应用应该是,任务中有等待的时间,这个等待时间如果交给一个线程做就堵塞在这块了。如果交由多个线程去做,会充分利用等待时间,去做其他事情。这才是多线程的意思。在我们日常工作中,像IO,网络,图片处理等,有些地方都是需要等待的,这几块用多线程,可能会提高效率。

当然,也有一种情况,比如多个用户访问后台接口,每个用户访问其实都是一个单独的线程,假如想计算累计有多少次访问的话,就需要用到多线程累加。

同类型文章

感兴趣的也可以参考我的另外一篇文章,多线程计算数组之和。

参考资料

深入理解synchronized(synchronized锁住的是代码还是对象)

深入理解java并发之sychronized实现原理

java中Sychronized用法

到此这篇关于java多线程累加计数的实现方法的文章就介绍到这了,更多相关java多线程累加计数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • jmeter+ant+jenkins自动化测试环境配置搭建过程

    jmeter+ant+jenkins自动化测试环境配置搭建过程

    在搭建jmeter+ant+jenkins环境有些前提条件,那就是要先配置好java环境、安装好jenkins以及配置好jmeter,这样才能省去很多的事情,对jmeter+ant+jenkins自动化测试环境配置搭建过程感兴趣的朋友一起看看吧
    2021-12-12
  • 使用java写的矩阵乘法实例(Strassen算法)

    使用java写的矩阵乘法实例(Strassen算法)

    这篇文章主要给大家介绍了关于如何使用java写的矩阵乘法(Strassen算法)的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-02-02
  • Springboot整合FreeMarker的实现示例

    Springboot整合FreeMarker的实现示例

    本文主要介绍了Springboot整合FreeMarker的实现示例,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-02-02
  • Mybatis 实现动态组装查询条件,仿SQL模式

    Mybatis 实现动态组装查询条件,仿SQL模式

    这篇文章主要介绍了Mybatis 实现动态组装查询条件,仿SQL模式的操作,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-06-06
  • Mybatis 中如何判断集合的size

    Mybatis 中如何判断集合的size

    这篇文章主要介绍了在Mybatis中判断集合的size操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-02-02
  • mybatisplus解决驼峰命名映射问题详解

    mybatisplus解决驼峰命名映射问题详解

    这篇文章主要介绍了mybatisplus解决驼峰命名映射问题详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-09-09
  • SpringBoot+slf4j实现全链路调用日志跟踪的方法(一)

    SpringBoot+slf4j实现全链路调用日志跟踪的方法(一)

    本文重点给大家介绍Tracer集成的slf4j MDC功能,方便用户在只简单修改日志配置文件的前提下输出当前 Tracer 上下文 TraceId,文章通过代码给大家讲解了在springboot中使用的技巧,感兴趣的朋友跟随小编一起看看吧
    2021-05-05
  • SpringBoot结果封装和异常拦截的实现示例

    SpringBoot结果封装和异常拦截的实现示例

    SpringBoot 项目中,我们通常需要将结果数据封装成特定的格式,以方便客户端进行处理,本文主要介绍了SpringBoot 优雅的结果封装和异常拦截,感兴趣的可以了解一下
    2023-08-08
  • 使用Springboot打成jar包thymeleaf的问题

    使用Springboot打成jar包thymeleaf的问题

    这篇文章主要介绍了使用Springboot打成jar包thymeleaf的问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-11-11
  • 深度剖析Java中的内存原型及工作原理

    深度剖析Java中的内存原型及工作原理

    这篇文章主要介绍了深度剖析Java中的内存原型及工作原理,本文讲解了java虚拟机内存原型、常量池、Java内存分配中的栈、Java内存分配中的堆等内容,需要的朋友可以参考下
    2015-01-01

最新评论