Java 多线程锁的深入探究

最新推荐文章于 2024-07-13 13:55:40 发布

道长不会写代码

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量345

点赞数 7

分类专栏：每天一道Java面试题文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/weixin_42545951/article/details/140332031

版权

每天一道Java面试题专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java 多线程锁的深入探究

在 Java 多线程编程中，锁是确保线程安全和避免数据竞争的重要工具。本文将深入探讨 Java 中常见的几种锁机制，帮助您更好地理解和应用多线程编程。

一、为什么需要锁

在多线程环境下，多个线程可能同时访问和修改共享数据，如果不加以控制，可能会导致数据不一致、程序错误甚至崩溃。锁的作用就是在同一时间只允许一个线程访问被保护的资源，从而保证数据的完整性和一致性。

二、Java 中的锁类型

（一）悲观锁

悲观锁总是假设最坏的情况，每次去获取数据的时候都认为别人会修改，所以每次在获取数据的时候都会上锁。常见的悲观锁实现方式是 synchronized 关键字。

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }).start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(example.getCount());
    }
}

在上述示例中，increment 方法使用 synchronized 关键字修饰，保证了在同一时刻只有一个线程能够执行该方法，从而保证了 count 变量的线程安全。

（二）乐观锁

乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测。如果发现冲突了，则返回错误信息，让用户决定如何去做。常见的乐观锁实现方式是 Atomic 类。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) {
        AtomicExample example = new AtomicExample();
        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        }).start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(example.getCount());
    }
}

在这个示例中，使用 AtomicInteger 来保证 count 的线程安全，它内部通过一些无锁的算法实现了高效的并发操作。

（三）读写锁

读写锁将对资源的访问分为读操作和写操作。读操作可以并发执行，而写操作是排他的。ReentrantReadWriteLock 类是 Java 中读写锁的实现。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int data = 0;
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void readData() {
        lock.readLock().lock();
        try {
            System.out.println("Reading data: " + data);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void writeData(int newData) {
        lock.writeLock().lock();
        try {
            data = newData;
            System.out.println("Writing data: " + newData);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();

        new Thread(() -> {
            example.readData();
        }).start();

        new Thread(() -> {
            example.readData();
        }).start();

        new Thread(() -> {
            example.writeData(100);
        }).start();
    }
}