java多线程共享成员变量的安全问题

最新推荐文章于 2023-06-14 14:06:04 发布

Guo_Xiaoxi

最新推荐文章于 2023-06-14 14:06:04 发布

阅读量926

点赞数

分类专栏： Java 多线程文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/Guo_Xiaoxi/article/details/103537715

版权

Java 同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

1、问题描述

批量变更产品专员，为产品专员开通对应的产品权限时，使用多线程执行任务。出现的问题是：批量开通100个产品权限时，只开通了几个产品的权限，其他产品的权限并未开通。通过分析日志，发现调用开通权限的接口，入参是最后一个产品ID的记录有61个，其余39个请求，也有重复的产品ID，并不是100个不同的产品ID作为开通权限的入参。

2、问题分析

代码中创建线程的类实现Runnable 接口，重写run方法，通过构造函数为成员变量赋值，使用ThreadPoolTaskExecutor的submit方法提交线程，
查看配置如下

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
		<property name="threadNamePrefix" value="taskExecutor-" />
		<property name="corePoolSize" value="10" />
		<property name="keepAliveSeconds" value="100" />
		<property name="maxPoolSize" value="20" />
		<property name="queueCapacity" value="10000" />
</bean>

参数解释

threadNamePrefix： 线程名称预设前缀
corePoolSize： 线程池核心线程数（默认值：1）
maximumPoolSize：线程池最大数（默认值：0x7fffffff转化为10进制为2^31-1）
keepAliveSeconds： 空闲线程存活时间（默认值：60）
queueCapacity： 阻塞任务队列（默认值：0x7fffffff转化为10进制为2^31-1）
allowCoreThreadTimeOut：销毁机制（默认值：false）没有timeout值的时候始终保持在maxPoolSize水平；如果有timeout情况，那么保持在corePoolSize水平

ThreadPoolTaskExecutor中还定义了一个私有属性

    private ThreadPoolExecutor threadPoolExecutor;
    
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {

		BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);
		ThreadPoolExecutor executor  = new ThreadPoolExecutor(
				this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
				queue, threadFactory, rejectedExecutionHandler);
		if (this.allowCoreThreadTimeOut) {
			executor.allowCoreThreadTimeOut(true);
		}

		this.threadPoolExecutor = executor;
		return executor;
	}

ThreadPoolTaskExecutor接收的入参，传递给ThreadPoolExecutor构造函数

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize： 线程池核心线程数
maximumPoolSize：线程池最大数
keepAliveTime： 空闲线程存活时间
unit： 时间单位
workQueue： 线程池所使用的缓冲队列
threadFactory：线程池创建线程使用的工厂
handler： 线程池对拒绝任务的处理策略

问题分析结论：经过分析代码，查询多线程相关资料，确认是多线程并发共享成员变量导致的问题。

4、问题复现

创建实体类ProductEntity

public class ProductEntity {
    private Integer productId;
    public Integer getProductId() {
        return productId;
    }
    public void setProductId(Integer productId) {
        this.productId = productId;
    }
}

创建线程类MemberVariableOfThreadTest

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MemberVariableOfThreadTest  implements  Runnable{

    private ProductEntity productEntity;

    public MemberVariableOfThreadTest(ProductEntity productEntity){
        this.productEntity = productEntity;
    }

    @Override
    public void run(){
            System.out.println(Thread.currentThread().getName()+"测试成员变量 i = " + productEntity.getProductId());
    }

    public static void main(String args[])
    {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,20,100L,TimeUnit.SECONDS,new LinkedBlockingQueue<>(10000));
        ProductEntity productEntity = new ProductEntity();

        for(int k=0;k<100;k++){
            productEntity.setProductId(k);
            MemberVariableOfThreadTest  thread = new MemberVariableOfThreadTest (productEntity);
            executor.submit(thread);
        }
    }
}

打印结果

pool-1-thread-1测试成员变量 i = 2
pool-1-thread-4测试成员变量 i = 4
pool-1-thread-3测试成员变量 i = 3
pool-1-thread-2测试成员变量 i = 2
pool-1-thread-5测试成员变量 i = 4
pool-1-thread-6测试成员变量 i = 6
pool-1-thread-7测试成员变量 i = 7
pool-1-thread-8测试成员变量 i = 8
pool-1-thread-9测试成员变量 i = 10
pool-1-thread-10测试成员变量 i = 13
pool-1-thread-9测试成员变量 i = 16
pool-1-thread-2测试成员变量 i = 17
pool-1-thread-3测试成员变量 i = 19
pool-1-thread-1测试成员变量 i = 16
pool-1-thread-10测试成员变量 i = 16
pool-1-thread-1测试成员变量 i = 21
pool-1-thread-7测试成员变量 i = 21
pool-1-thread-4测试成员变量 i = 19
pool-1-thread-6测试成员变量 i = 19
pool-1-thread-10测试成员变量 i = 25
pool-1-thread-9测试成员变量 i = 19
pool-1-thread-5测试成员变量 i = 19
pool-1-thread-10测试成员变量 i = 26
pool-1-thread-8测试成员变量 i = 25
pool-1-thread-4测试成员变量 i = 25
pool-1-thread-7测试成员变量 i = 22
pool-1-thread-2测试成员变量 i = 21
pool-1-thread-7测试成员变量 i = 31
pool-1-thread-8测试成员变量 i = 30
pool-1-thread-6测试成员变量 i = 30
pool-1-thread-10测试成员变量 i = 30
pool-1-thread-5测试成员变量 i = 38
pool-1-thread-1测试成员变量 i = 30
pool-1-thread-5测试成员变量 i = 38
pool-1-thread-2测试成员变量 i = 38
pool-1-thread-10测试成员变量 i = 38
pool-1-thread-8测试成员变量 i = 41
pool-1-thread-3测试成员变量 i = 34
pool-1-thread-9测试成员变量 i = 33
pool-1-thread-7测试成员变量 i = 33
pool-1-thread-7测试成员变量 i = 45
pool-1-thread-9测试成员变量 i = 44
pool-1-thread-3测试成员变量 i = 43
pool-1-thread-8测试成员变量 i = 42
pool-1-thread-4测试成员变量 i = 41
pool-1-thread-6测试成员变量 i = 41
pool-1-thread-9测试成员变量 i = 52
pool-1-thread-5测试成员变量 i = 52
pool-1-thread-8测试成员变量 i = 58
pool-1-thread-4测试成员变量 i = 52
pool-1-thread-10测试成员变量 i = 52
pool-1-thread-3测试成员变量 i = 48
pool-1-thread-7测试成员变量 i = 47
pool-1-thread-1测试成员变量 i = 47
pool-1-thread-7测试成员变量 i = 67
pool-1-thread-3测试成员变量 i = 65
pool-1-thread-8测试成员变量 i = 63
pool-1-thread-10测试成员变量 i = 63
pool-1-thread-4测试成员变量 i = 62
pool-1-thread-6测试成员变量 i = 58
pool-1-thread-6测试成员变量 i = 75
pool-1-thread-5测试成员变量 i = 58
pool-1-thread-2测试成员变量 i = 56
pool-1-thread-9测试成员变量 i = 56
pool-1-thread-2测试成员变量 i = 76
pool-1-thread-5测试成员变量 i = 76
pool-1-thread-6测试成员变量 i = 76
pool-1-thread-4测试成员变量 i = 73
pool-1-thread-10测试成员变量 i = 73
pool-1-thread-8测试成员变量 i = 71
pool-1-thread-3测试成员变量 i = 70
pool-1-thread-3测试成员变量 i = 99
pool-1-thread-3测试成员变量 i = 99
pool-1-thread-7测试成员变量 i = 67
pool-1-thread-1测试成员变量 i = 67
pool-1-thread-7测试成员变量 i = 99
pool-1-thread-3测试成员变量 i = 99
pool-1-thread-8测试成员变量 i = 95
pool-1-thread-10测试成员变量 i = 93
pool-1-thread-4测试成员变量 i = 92
pool-1-thread-6测试成员变量 i = 89
pool-1-thread-5测试成员变量 i = 89
pool-1-thread-2测试成员变量 i = 86
pool-1-thread-9测试成员变量 i = 84
pool-1-thread-2测试成员变量 i = 99
pool-1-thread-5测试成员变量 i = 99
pool-1-thread-6测试成员变量 i = 99
pool-1-thread-4测试成员变量 i = 99
pool-1-thread-10测试成员变量 i = 99
pool-1-thread-8测试成员变量 i = 99
pool-1-thread-3测试成员变量 i = 99
pool-1-thread-7测试成员变量 i = 99
pool-1-thread-1测试成员变量 i = 99
pool-1-thread-8测试成员变量 i = 99
pool-1-thread-10测试成员变量 i = 99
pool-1-thread-4测试成员变量 i = 99
pool-1-thread-6测试成员变量 i = 99
pool-1-thread-5测试成员变量 i = 99
pool-1-thread-2测试成员变量 i = 99
pool-1-thread-9测试成员变量 i = 99

线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果

5、解决方案

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MemberVariableOfThreadTest2  implements  Runnable{

    private volatile ProductEntity productEntity;

    public MemberVariableOfThreadTest2(ProductEntity productEntity){
        this.productEntity = productEntity;
    }

    @Override
    public void run(){
        try {
            Thread.sleep(10);
            System.out.println(Thread.currentThread().getName()+"测试成员变量 i = " + productEntity.getProductId());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void testThreadRun(int k,ThreadPoolExecutor executor){
        ProductEntity productEntity = new ProductEntity();
        productEntity.setProductId(k);
        MemberVariableOfThreadTest2  thread = new MemberVariableOfThreadTest2 (productEntity);
        executor.submit(thread);
    }

    public static void main(String args[])
    {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,20,100L,TimeUnit.SECONDS,new LinkedBlockingQueue<>(10000));
        
        long startTime = System.currentTimeMillis();
        for(int k=0;k<100;k++){
            testThreadRun(k,executor);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Cost Time: " + (endTime - startTime) + "ms");
    }

}

打印结果

Cost Time: 4ms
pool-1-thread-1测试成员变量 i = 0
pool-1-thread-2测试成员变量 i = 1
pool-1-thread-3测试成员变量 i = 2
pool-1-thread-4测试成员变量 i = 3
pool-1-thread-5测试成员变量 i = 4
pool-1-thread-6测试成员变量 i = 5
pool-1-thread-7测试成员变量 i = 6
pool-1-thread-9测试成员变量 i = 8
pool-1-thread-8测试成员变量 i = 7
pool-1-thread-10测试成员变量 i = 9
pool-1-thread-1测试成员变量 i = 10
pool-1-thread-4测试成员变量 i = 12
pool-1-thread-5测试成员变量 i = 14
pool-1-thread-2测试成员变量 i = 11
pool-1-thread-3测试成员变量 i = 13
pool-1-thread-6测试成员变量 i = 15
pool-1-thread-7测试成员变量 i = 16
pool-1-thread-9测试成员变量 i = 17
pool-1-thread-8测试成员变量 i = 18
pool-1-thread-10测试成员变量 i = 19
pool-1-thread-1测试成员变量 i = 20
pool-1-thread-4测试成员变量 i = 21
pool-1-thread-3测试成员变量 i = 24
pool-1-thread-5测试成员变量 i = 22
pool-1-thread-2测试成员变量 i = 23
pool-1-thread-7测试成员变量 i = 26
pool-1-thread-6测试成员变量 i = 25
pool-1-thread-9测试成员变量 i = 27
pool-1-thread-8测试成员变量 i = 28
pool-1-thread-10测试成员变量 i = 29
pool-1-thread-1测试成员变量 i = 30
pool-1-thread-3测试成员变量 i = 32
pool-1-thread-2测试成员变量 i = 34
pool-1-thread-4测试成员变量 i = 31
pool-1-thread-5测试成员变量 i = 33
pool-1-thread-7测试成员变量 i = 35
pool-1-thread-6测试成员变量 i = 36
pool-1-thread-9测试成员变量 i = 37
pool-1-thread-8测试成员变量 i = 38
pool-1-thread-10测试成员变量 i = 39
pool-1-thread-1测试成员变量 i = 40
pool-1-thread-3测试成员变量 i = 41
pool-1-thread-7测试成员变量 i = 45
pool-1-thread-5测试成员变量 i = 44
pool-1-thread-6测试成员变量 i = 46
pool-1-thread-4测试成员变量 i = 43
pool-1-thread-2测试成员变量 i = 42
pool-1-thread-9测试成员变量 i = 47
pool-1-thread-8测试成员变量 i = 48
pool-1-thread-10测试成员变量 i = 49
pool-1-thread-1测试成员变量 i = 50
pool-1-thread-3测试成员变量 i = 51
pool-1-thread-7测试成员变量 i = 52
pool-1-thread-5测试成员变量 i = 53
pool-1-thread-2测试成员变量 i = 56
pool-1-thread-4测试成员变量 i = 55
pool-1-thread-6测试成员变量 i = 54
pool-1-thread-9测试成员变量 i = 57
pool-1-thread-8测试成员变量 i = 58
pool-1-thread-10测试成员变量 i = 59
pool-1-thread-1测试成员变量 i = 60
pool-1-thread-3测试成员变量 i = 61
pool-1-thread-2测试成员变量 i = 64
pool-1-thread-5测试成员变量 i = 63
pool-1-thread-7测试成员变量 i = 62
pool-1-thread-4测试成员变量 i = 65
pool-1-thread-6测试成员变量 i = 66
pool-1-thread-9测试成员变量 i = 67
pool-1-thread-10测试成员变量 i = 69
pool-1-thread-8测试成员变量 i = 68
pool-1-thread-1测试成员变量 i = 70
pool-1-thread-2测试成员变量 i = 72
pool-1-thread-6测试成员变量 i = 76
pool-1-thread-4测试成员变量 i = 75
pool-1-thread-7测试成员变量 i = 74
pool-1-thread-5测试成员变量 i = 73
pool-1-thread-3测试成员变量 i = 71
pool-1-thread-9测试成员变量 i = 77
pool-1-thread-8测试成员变量 i = 79
pool-1-thread-10测试成员变量 i = 78
pool-1-thread-2测试成员变量 i = 81
pool-1-thread-6测试成员变量 i = 82
pool-1-thread-4测试成员变量 i = 83
pool-1-thread-7测试成员变量 i = 84
pool-1-thread-5测试成员变量 i = 85
pool-1-thread-1测试成员变量 i = 80
pool-1-thread-3测试成员变量 i = 86
pool-1-thread-9测试成员变量 i = 87
pool-1-thread-8测试成员变量 i = 88
pool-1-thread-10测试成员变量 i = 89
pool-1-thread-2测试成员变量 i = 90
pool-1-thread-6测试成员变量 i = 91
pool-1-thread-4测试成员变量 i = 92
pool-1-thread-7测试成员变量 i = 93
pool-1-thread-5测试成员变量 i = 94
pool-1-thread-3测试成员变量 i = 96
pool-1-thread-1测试成员变量 i = 95
pool-1-thread-9测试成员变量 i = 97
pool-1-thread-8测试成员变量 i = 98
pool-1-thread-10测试成员变量 i = 99

Guo_Xiaoxi

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java多线程共享成员变量的安全问题

1、问题描述批量变更产品专员时，为产品专员开通对应产品权限时，是用多线程任务去执行的，出现的问题时，批量开通100个产品权限时，可能只真正开通几个产品的权限，其他产品的权限并未开通。通过分析日志，发现调用开通权限的接口，入参是最后一个产品ID的记录有61个，剩余39个请求，也有重复的产品ID，怀疑多线程并发问题导致2、问题分析创建线程的类实现Runnable 类接口，重写run方法，通过构造...
复制链接

扫一扫