并发编程--synchronized、volatile、ThreadLocal的使用

本文深入探讨并发编程中的关键概念,包括synchronized关键字的正确使用、volatile变量确保线程间可见性的机制,以及ThreadLocal解决线程安全问题的独特方式。通过具体代码示例,解析常见错误与最佳实践。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

并发编程–synchronized、volatile、ThreadLocal的使用

1.synchronized内置锁

加锁目标对象

  • 对象锁
  • 类锁

加锁的注意事项:

  1. 各个线程竞争锁的目标对象必须是同一个。
  2. 各个线程竞争锁的目标对象不能更改,例如:
/**
 * 类说明:错误的加锁和原因分析
 */
public class TestIntegerSyn {

    public static void main(String[] args) throws InterruptedException {
        Worker worker=new Worker(1);
        //Thread.sleep(50);
        for(int i=0;i<5;i++) {
            new Thread(worker).start();
        }
    }

    private static class Worker implements Runnable{

        private Integer i;
        private Object o = new Object();

        public Worker(Integer i) {
            this.i=i;
        }

        @Override
        public void run() {
            synchronized (o) {
                Thread thread=Thread.currentThread();
                System.out.println(thread.getName()+"--@"
                        +System.identityHashCode(i));
                i++;
                System.out.println(thread.getName()+"-------"+i+"-@"
                        +System.identityHashCode(i));
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName()+"-------"+i+"--@"
                        +System.identityHashCode(i));
            }

        }

    }
}

注意:i++时,Integer内部会对i对象进行修改,i++ == Interger.valueOf(i) + 1 ,然而valueOf(i)会new Integer(i),所以上面代码中,i的对象会发生变化,导致各个线程竞争锁的目标对象没有保持不变。

2. volatile 的使用(适用于一读多写)

volatile 保证了对象在各个线程间的可见性,不能保证原子性,但能保持可见性,是最轻量的同步机制。
测试代码:

public class VolatileTest {

    private static boolean flag;  
    //private static volatile boolean flag;

    static class VolatileTestRunable implements Runnable{

        @Override
        public void run() {
            System.out.println("test runable is starting flag: "+flag);
            while (!flag){}
                System.out.println("enter volatile ,modify is effective flag: "+ flag);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new VolatileTestRunable()).start();
        TimeUnit.SECONDS.sleep(1);
        flag = true;
        TimeUnit.SECONDS.sleep(1);
        System.out.println("main thread is end");
    }
}

运行结果:(不加volatile)

test runable is starting flag: false
main thread is end

运行结果:(加volatile)

test runable is starting flag: false
enter volatile ,modify is effective flag: true
main thread is end

3.ThreadLocal 的使用

package cn.enjoyedu.ch1.threadlocal;

/**
 *类说明:演示ThreadLocal的使用
 */
public class UseThreadLocal {
	
	private static ThreadLocal<Integer> intLocal
            = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 1;
        }
    };

    private static ThreadLocal<String> stringThreadLocal;

    /**
     * 运行3个线程
     */
    public void StartThreadArray(){
        Thread[] runs = new Thread[3];
        for(int i=0;i<runs.length;i++){
            runs[i]=new Thread(new TestThread(i));
        }
        for(int i=0;i<runs.length;i++){
            runs[i].start();
        }
    }
    
    /**
     *类说明:测试线程,线程的工作是将ThreadLocal变量的值变化,并写回,看看线程之间是否会互相影响
     */
    public static class TestThread implements Runnable{
        int id;
        public TestThread(int id){
            this.id = id;
        }
        public void run() {
            System.out.println(Thread.currentThread().getName()+":start");
            Integer s = intLocal.get();
            s = s+id;
            intLocal.set(s);
            System.out.println(Thread.currentThread().getName()
                    +":"+ intLocal.get());
            //intLocal.remove();
        }
    }

    public static void main(String[] args){
    	UseThreadLocal test = new UseThreadLocal();
        test.StartThreadArray();
    }
}

运行结果:

Thread-0:start
Thread-2:start
Thread-2:3
Thread-1:start
Thread-0:1
Thread-1:2

ThreadLocal Map使用原理:
在这里插入图片描述
ThreadLocal Map底层原理:
在这里插入图片描述
ThreadLocal导致的内存泄露:
(原因分析)由于Entry(k,v),k为虚引用,当发生Gc的时候,threadLocal instance 被回收,不能通过threadLocal instance访问currentThread中的Entry[]时,但是Value在ThreadLocalMap中被声明为强引用,value是不会被回收的,导致value不能通过任何路径来访问,所以导致内存泄漏。
(补救措施)threadLocalref的get,set,remove方法中会调用 replaceStaleEntry(key, value, i)方法对key为空的entry进行回收,减少内存泄漏。

为何不声明成强引用?
答:如果把threadLocalinstance 声明成强引用,当对entry进行回收的时候,entry会对threadLocalinstance强依赖,导致内存泄漏,如果声明成虚引用,还有可能使用replaceStaleEntry进行内存回收。
扩展:ThreadLocal在事务中的使用:参考:spring在事务中的使用

内容概要:文章基于4A架构(业务架构、应用架构、数据架构、技术架构),对SAP的成本中心和利润中心进行了详细对比分析。业务架构上,成本中心是成本控制的责任单元,负责成本归集与控制,而利润中心是利润创造的独立实体,负责收入、成本和利润的核算。应用架构方面,两者都依托于SAP的CO模块,但功能有所区分,如成本中心侧重于成本要素归集和预算管理,利润中心则关注内部交易核算和获利能力分析。数据架构中,成本中心与利润中心存在多对一的关系,交易数据通过成本归集、分摊和利润计算流程联动。技术架构依赖SAP S/4HANA的内存计算和ABAP技术,支持实时核算与跨系统集成。总结来看,成本中心和利润中心在4A架构下相互关联,共同为企业提供精细化管理和决策支持。 适合人群:从事企业财务管理、成本控制或利润核算的专业人员,以及对SAP系统有一定了解的企业信息化管理人员。 使用场景及目标:①帮助企业理解成本中心和利润中心在4A架构下的运作机制;②指导企业在实施SAP系统时合理配置成本中心和利润中心,优化业务流程;③提升企业对成本和利润的精细化管理水平,支持业务决策。 其他说明:文章不仅阐述了理论概念,还提供了具体的应用场景和技术实现方式,有助于读者全面理解并应用于实际工作中。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值