java多线程累加计数_创建5个线程,每个线程做20000次累和-CSDN博客

java 多线程计数

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

思路
创建一个类MyRunnable，实现Runnable（继承Thread类也可）
定义一个公共变量count(初始值为0)，5个线程都可以访问到；
创建5个线程并发递增count到1000；
方法
方法一
将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(this)代表锁住同一对象。
synchronized(MyRunnable.class)代表锁住整个MyRunnable类的对象。
方法三
使用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用法
---------------------
作者：安迪爸爸
来源：CSDN
原文：https://blog.csdn.net/wzmde007/article/details/79641084
版权声明：本文为博主原创文章，转载请附上博文链接！