java实现锁几种方式

Java中实现锁主要有以下几种方式：

1、synchronized关键字

2、ReentrantLock类

3、Semaphore类

4、CountDownLatch类

5、CyclicBarrier类

6、StampedLock类

下面是详细的解释和示例代码：

1. synchronized关键字

synchronized关键字可以用于方法或者代码块，当一个线程访问被synchronized修饰的方法或代码块时，其他线程无法访问该对象。

public class SynchronizedExample {
    private Object lock = new Object();
    public void method1() {
        synchronized (lock) {
            // 临界区代码
        }
    }
    public void method2() {
        synchronized (lock) {
            // 临界区代码
        }
    }
}

2. ReentrantLock类

ReentrantLock是一个可重入的互斥锁，它提供了与synchronized关键字相同的基本行为和语义，但具有更高的扩展性。

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    public void method1() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }
    public void method2() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }
}

3. Semaphore类

Semaphore是一个计数信号量，可以用来控制同时访问某个资源的线程数量。

import java.util.concurrent.Semaphore;
public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1);
    public void method1() {
        try {
            semaphore.acquire();
            // 临界区代码
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
    public void method2() {
        try {
            semaphore.acquire();
            // 临界区代码
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

4. CountDownLatch类

CountDownLatch是一个同步辅助类，它允许一个或多个线程等待直到一组操作完成。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(1);
    public void method1() {
        new Thread(() > {
            try {
                // 执行任务
                latch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
    public void method2() {
        try {
            latch.await();
            // 临界区代码
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5. CyclicBarrier类

CyclicBarrier是一个同步辅助类，它允许一组线程相互等待，直到所有线程都到达某个屏障点。

import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(2);
    public void method1() {
        new Thread(() > {
            try {
                // 执行任务
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
    public void method2() {
        new Thread(() > {
            try {
                // 执行任务
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}

6. StampedLock类

StampedLock是一个读写锁，它提供了乐观读锁和悲观读锁，以及一种基于版本号的写锁。

import java.util.concurrent.locks.StampedLock;
public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    public void method1() {
        long stamp = lock.writeLock();
        try {
            // 临界区代码
        } finally {
            lock.unlockWrite(stamp);
        }
    }
    public void method2() {
        long stamp = lock.readLock();
        try {
            // 临界区代码
        } finally {
            lock.unlockRead(stamp);
        }
    }
}