Java延时实例分析：Lock vs Synchronized(Java延时对比解析：Lock与Synchronized性能差异探讨)

原创

ithorizon 6个月前 (10-19) 阅读数 27 #后端开发

Java延时实例分析：Lock vs Synchronized

一、引言

在Java多线程编程中，同步机制是确保线程保险的关键。Java提供了多种同步机制，其中最常用的两种是synchronized关键字和Lock接口。本文将通过一个延时实例来分析Lock和synchronized的性能差异，并探讨它们在实际应用中的优缺点。

二、Lock与synchronized简介

1. synchronized关键字：synchronized是Java内置的同步机制，它通过在代码块或方法上添加synchronized关键字来实现同步。当一个线程访问一个对象的synchronized方法或代码块时，它会自动获得该对象的监视器锁，其他线程必须等待该线程释放锁后才能访问。

2. Lock接口：Lock是Java 5引入的一个高级同步机制，它提供了比synchronized更灵活的同步控制。Lock接口的实现类如ReentrantLock提供了更多功能，如可中断的锁获取、公平锁和非公平锁等。

三、延时实例分析

以下是一个简洁的延时实例，我们将分别使用synchronized和Lock来实现，并对比它们的性能。


public class DelayExample {
    private static final int LOOP_COUNT = 1000000;
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.nanoTime();
        synchronizedMethod();
        long endTime = System.nanoTime();
        System.out.println("synchronized耗时：" + (endTime - startTime) + "纳秒");
        startTime = System.nanoTime();
        lockMethod();
        endTime = System.nanoTime();
        System.out.println("Lock耗时：" + (endTime - startTime) + "纳秒");
    }
    public static void synchronizedMethod() throws InterruptedException {
        Object lock = new Object();
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                synchronized (lock) {
                    for (int j = 0; j < LOOP_COUNT; j++) {
                        // 空操作
                    }
                }
            });
            threads[i].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
    }
    public static void lockMethod() throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                lock.lock();
                try {
                    for (int j = 0; j < LOOP_COUNT; j++) {
                        // 空操作
                    }
                } finally {
                    lock.unlock();
                }
            });
            threads[i].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
    }
}