java 多线程求和的几种实现方式。

最新推荐文章于 2024-01-11 18:16:52 发布
最新推荐文章于 2024-01-11 18:16:52 发布
阅读量3k 收藏 16
点赞数
分类专栏： Java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hagle_wang/article/details/106382131
版权

前情提要

通过本文你可以收获

  1. 通过多线程计数求和了解synchronized的应用场景，以及其他加锁方式为什么不生效
  2. 框架 对象锁和类锁

1、同一时刻只有一个线程执行这段代码
2、最基本的互斥同步手段
3、分类 一共有俩种锁：
1、对象锁
1、同步代码块锁
2、方法锁
3 类锁

案例演示与分析：

1、不使用锁 求和会出问题

public class MutilThreadCount implements  Runnable{
    static int sum = 0;
    @Override
    public void run() {
        //synchronized (this){
            for (int i = 0; i < 100000; i++) {
                sum++;
            }
        //}
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}

预期结果200000 结果小于200000

2、使用volatile也会出问题

public class MutilThreadCount implements  Runnable{
    static volatile int sum = 0;
    @Override
    public void run() {
        //synchronized (this){
            for (int i = 0; i < 100000; i++) {
                sum++;
            }
        //}
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}
预期结果200000 结果小于200000
volititle有俩个特征：
  1、变量对线程是可见的
 虽然变量对各个线程是可见的， 但是sum++不是原子的，包含了获取值，自增，赋值 每一个操作都可能被其他线程打断 修改了变量的值
  2、防止指令重排
  例子就是双重懒加载的单例模式

img

3、不锁同一个对象 求和会出问题

public class MutilThreadCount implements  Runnable{
    Object lock1 = new Object();
    Object lock2 = new Object();
    static int  sum = 0;
    @Override
    public void run() {
        synchronized (lock1){
            for (int i = 0; i < 100000; i++) {
                sum=sum+1;
            }
        }
        synchronized (lock2){
            for (int i = 0; i < 100000; i++) {
                sum=sum+1;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}
预期：400000  结果小于400000  第二个求和循环使用lock1就正确了

4、在方法上使用synchronized 求和正确

public class MutilThreadCount implements  Runnable{
    static int sum = 0;
    @Override
    public void run() {
        synchronized (this){
            for (int i = 0; i < 100000; i++) {
                sum++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}
预期200000结果200000

5、使用synchronized锁类 求和正确（锁类意味着锁住了Class对象 这个类所有的实例都被锁了 所以即使使用lock1和lock2也没问题 ）

public class MutilThreadCount implements  Runnable{

    static int  sum = 0;
    @Override
    public void run() {
        synchronized (MutilThreadCount.class){
            for (int i = 0; i < 100000; i++) {
                sum=sum+1;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}


下面是新建俩个线程对象  但因为是锁的类 ，所以结果也正确，但是如果锁this就不行了
public class MutilThreadCount implements  Runnable{

    private Object lock1  = new Object();
    private Object lock2  = new Object();

    static int  sum = 0;
    @Override
    public void run() {
        synchronized (MutilThreadCount.class){
            for (int i = 0; i < 100000; i++) {
                sum=sum+1;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count1 = new MutilThreadCount();
        MutilThreadCount count2 = new MutilThreadCount();

        Thread t1 = new Thread(count1);
        Thread t2 = new Thread(count2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}
预期20000  结果20000

6、使用AtomicInteger（更好的voltitle变量） 求和正确

public class MutilThreadCount implements  Runnable{
    static AtomicInteger sum = new AtomicInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sum.addAndGet(1);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MutilThreadCount count = new MutilThreadCount();
        Thread t1 = new Thread(count);
        Thread t2 = new Thread(count);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);
    }
}

7、使用CAS技术（p263） 学懂aqs需要对照着并发包一起学习

8、使用retreentlock

9、使用futuretask来做

voltitle讲解的不错

https://crossoverjie.top/%2F2018%2F03%2F09%2Fvolatile%2F
https://zhuanlan.zhihu.com/p/56191979

分析

为什么前面俩种结果不对？

sum++不是一个原子操作

分为三步：

  • 读取sum

  • 把sum+1

  • 把sum写回内存

俩个线程会在这三步中任何一步交替执行，扰乱了sum的值

为什么使用volitile也不行？不是传说中volitile是对线程可见的么？

为什么最后一种执行结果没问题：

在run方法中加了锁关键字就正常输出20000了

锁this也就是意味着给当前对象加了锁
synchronized可以简单的理解为同一时刻只有一个线程执行这段代码

​

肘后备急

synchronized

  1. 方法抛出异常 jvm会释放锁

  2. synchronized 作用于非static的方法 就是锁了对象 和作用于this一样

作用于static方法就是锁了类，锁了类也就是锁了这个类所有的对象实例，和synchronized（xx.class）作用一样

  1. 可重入:从外层函数获得锁后，内层函数可以直接获取该锁

同一个方法，不是同一个方法，不是一个类的方法都具有可重入性质，重入意味着获取锁的粒度是线程 不是调用。

可重入原理：

  1. 不可中断：

  2. 加锁和释放锁的原理

  3. 可见性原理：

    需要了解Java内存模型 共享变量和线程变量

    synchronize释放后 会把变量重新写入主内存，另一个线程也会从主内存中把数据拷贝到线程内存，

    但是为什么volitile不行？

  4. synchronize缺陷 ：

    1、释放锁的情况少，试图获得锁不能设定超时，不能中断一个正在试图获取锁的线程

    lock更好 可以手动释放锁和设置超时

    2、不够灵活 读写锁更灵活

    3、无法知道是否成功获取到锁

  5. synchronize只会在俩种情况下释放锁：

    第一就是执行完成任务，第二是抛出出异常

  6. 使用注意

    锁对象不能为空:因为锁的信息是保存在对象头中的

    作用域不要太大，会严重降低效率

    避免死锁

  7. 如何选择synchronize和Lock

    尽量不要使用这俩个，可以使用并发包下的

    优先使用synchronize 因为代码量少？

    如果需要Lock特性 那么就使用Lock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yFY7nzK7-1590563267129)(/Users/wwh/Library/Application Support/typora-user-images/image-20200303001609889.png)]

新线君
关注
专栏目录
Java实现：N个线程并行对数组求和
weixin_40800275的博客
08-27 173
Java实现多线程实现数组求和，给定一个数组 int array[]，如何用N个线程进行求和。
java 多线程求和_java多线程面试 - 多线程求和
weixin_42499067的博客
02-13 2965
今天面试过程中碰到一个简单的多线程面试题目，竟然一时钻了牛角尖，没有回答上来，结束面试立刻醒悟过来，想想真丢人。面试题目如下：如何多线程计算 1+2+3+……n，其中n是一个很大的数值，不使用直接的求职公式。因为总是碰到类似于计数器的问题，(多个线程进行计数)，所以思路不自觉的就转到了计数器的处理思路上去了：设置多个线程共享的一个 Integer sum，然后多个线程瓜分 1到n 的整数值，并分别...
【多线程】——join()方法实现并行计算
闲着没事_玩玩JAVA的专栏
10-26 880
public class Test12 { /* * 并行计算实现1~10000求和 */ public static void main(String[] args) throws InterruptedException { MyRunn myRunn1=new MyRunn(0,10000); MyRunn myRunn2=new MyRunn(1,10000);
08-多线程
Wuyikkk的博客
04-28 278
一、线程 1.说明 1. 线程，是程序内部的一条执行路径。 2. 如果一个进程同一时间并行执行多个线程，则为支持多线程。 3。 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。 4. 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带...
Java 多线程实现1到1千万的求和操作
白白白鲤鱼的博客
05-31 1294
Java 多线程实现1到1千万的求和操作
Java 多线程求和1+2+3+.....+100；
weixin_45898427的博客
05-21 3296
1. 提到Java多线程求和我们首先想到的是new 多个Thread，然后给每个线程内写一个for循环来求和，如下 package Demo1; public class sum { public static void main(String[] args) { new Thread(()->{ int sum = 0; for (int i = 0; i < 10; i++) { su
java 多线程求和_Java多线程求和
weixin_28818721的博客
02-24 479
package test;import java.util.concurrent.*; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class SumService {private final Integer nthread;private final...
【Java多线程实战】求和
风暴计划
10-24 1933
Java多线程实战-求和   需求：开启五个线程，每个线程对一个给定数值从0开始累加求和。 （1）MyCallable.java package com.storm_02; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.Calla...
多线程求和
12-12
winform中的多线程求和
java多线程并发
weixin_48288539的博客
10-27 3275
介绍java线程并发机制
Java多线程实现文件操作与分数计算
"此资源是一个关于Java多线程编程的实例，通过一个具体的应用场景展示了如何在Java中实现多线程处理。程序涉及到文件操作、数据计算以及用户交互，旨在帮助学习者理解Java多线程的概念和实践应用。" 在Java编程中，...
Java多线程 --Thread
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
08-09 434
多线程
线程创建的4种方式和实现线程安全问题3种方式
weixin_44195525的博客
12-08 588
线程 1.线程介绍 （1）什么是进程？线程？程序？ **程序（program）：**是为了完成特定的语言编写的一组指令的集合。即是一段特定的代码。 **进程（process）：**程序的一次执行过程，或正在运行的一个程序。 **线程：（thread:**进程可进一步化为线程，是一个程序内部的一条执行路径。 （2）并行和并发的理解 单核CPU和多核CPU的理解 单核CPU，其实是一种假的线程，因为在一个时间单元内，也只能执行一个线程的内务。例如： 有很多车道，但是只有一个工作人员在收费，只
Java中的多线程机制
swimming_in_IT_的博客
08-10 1671
对于线程的理解一直有限，最近回看下线程，然后自己做个详细的记录吧！ 一 线程和进程的区别 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多
java 多线程求和_Java多线程求和 - 一滴水穿石的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_35916710的博客
02-13 161
`package test;import java.util.concurrent.*; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class SumService {private final Integer nthread;private fina...
java 多线程求和
最新发布
xiaofanren1111的博客
01-11 532
/ 将每个数字传递给sum()函数进行求和。上述代码会创建一个包含指定数量线程的线程池（在本例中与数组长度相同），然后将每个数组元素分配给不同的线程进行求和运算。// 提交任务到线程池。// 这里只是简单地返回输入值的平方作为示例。// 创建ExecutorService来管理线程池。// 定义FutureTask列表存放每个任务的结果。// 获取每个任务的结果并相加得到最终结果。方法从每个任务中获取结果，并将其相加得到最终的求和结果。// 等待所有任务完成。
[Java基础]多线程求和小例子
weixin_30745553的博客
07-31 77
看到一个线程题目，自己对线成不太了解，看看书，写个小例子。抛砖引玉吧 /*** 多线程求和* @author LIUYONG* 2011-07-31*/public class ThreadTestForSum implements Runnable { static Integer sum = 0; public static void main(String[...
java多线程面试 - 多线程求和
iteye_6270的博客
03-06 667
        今天面试过程中碰到一个简单的多线程面试题目，竟然一时钻了牛角尖，没有回答上来，结束面试立刻醒悟过来，想想真丢人。           面试题目如下：如何多线程计算 1+2+3+……n，其中n是一个很大的数值，不使用直接的求职公式。           因为总是碰到类似于计数器的问题，（多个线程进行计数），所以思路不自觉的就转到了计数器的处理思路上去了：设置多个线程共享的...
java多线程面试 - 多线程求和(转)
行动起来
04-03 389
java多线程面试 - 多线程求和 今天面试过程中碰到一个简单的多线程面试题目，竟然一时钻了牛角尖，没有回答上来，结束面试立刻醒悟过来，想想真丢人。 面试题目如下：如何多线程计算 1+2+3+……n，其中n是一个很大的数值，不使用直接的求职公式。 因为总是碰到类似于计数器的问题，（多个线程进行计数），所以思路不自...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值