Java 同步锁性能优化指南：从负担到高速的转变

 

使用同步锁的代码示例

package org.zyf.javabasic.thread.lock.opti;
 
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * @program: zyfboot-javabasic
 * @description: 使用了ReentrantLock来保护对共享资源（counter）的访问，确保同一时间只有一个线程可以对计数器进行操作。
 * @author: zhangyanfeng
 * @create: 2024-06-05 22:54
 **/
public class SyncLockExample {
    private static int counter = 0;
    private static final ReentrantLock lock = new ReentrantLock();
 
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        Thread[] threads = new Thread[100];
 
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(new IncrementWithLock());
            threads[i].start();
        }
 
        for (Thread thread : threads) {
            thread.join();
        }
 
        long endTime = System.currentTimeMillis();
        System.out.println("Time with lock: " + (endTime - startTime) + " ms");
    }
 
    static class IncrementWithLock implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000000; i++) {
                lock.lock();
                try {
                    counter++;
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

不使用同步锁的代码示例

package org.zyf.javabasic.thread.lock.opti;
 
/**
 * @program: zyfboot-javabasic
 * @description: 不使用任何同步机制，直接操作共享资源。
 * @author: zhangyanfeng
 * @create: 2024-06-05 22:55
 **/
public class NoSyncLockExample {
    private static int counter = 0;
 
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        Thread[] threads = new Thread[100];
 
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(new IncrementWithoutLock());
            threads[i].start();
        }
 
        for (Thread thread : threads) {
            thread.join();
        }
 
        long endTime = System.currentTimeMillis();
        System.out.println("Time without lock: " + (endTime - startTime) + " ms");
    }
 
    static class IncrementWithoutLock implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000000; i++) {
                counter++;
            }
        }
    }
}

结果与讨论

运行以上代码，我当前的机器上可以直观的看到

使用同步锁的时间: 1314 ms
不使用同步锁的时间: 20 ms
从结果中可以明显看出，同步锁会带来显著的性能开销。同步锁的存在增加了线程间的等待时间和上下文切换的开销，从而降低了程序的整体运行效率。所以在使用锁时，对锁的优化使用是必不可少的。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/xiaofeng10330111/article/details/139611703