从源代码角度看，Java中的线程同步问题

原创快来打我* 2024-12-02 13:39 14阅读 0赞

在Java中，线程同步主要是通过一些同步机制来实现的，以防止多个线程同时访问和修改共享资源。以下是一些主要的同步方式：

1. **synchronized关键字**：用于修饰方法或代码块，使得同一时刻只有一个线程可以执行这些代码。

```java
class Counter {
    private int count = 0;

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

public synchronized int getCount() {
        return count;
    }
}
```

2. **Lock接口与锁实现类**：提供更灵活的同步机制。如`ReentrantLock`。

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class LockDemo {
    private Lock lock = new ReentrantLock();

public void thread1() {
        lock.lock(); // 获取锁
        try {
            System.out.println("Thread 1: Running... ");
            Thread.sleep(3000); // 模拟耗时操作
        } finally {
            lock.unlock(); // 释放锁
            System.out.println("Thread 1: Finished.");
        }
    }

public void thread2() {
        lock.lock(); // 获取锁
        try {
            System.out.println("Thread 2: Running... ");
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            lock.unlock(); // 释放锁
            System.out.println("Thread 2: Finished.");
        }
    }

public void startThreads() {
        new Thread(thread1)).start();
        new Thread(thread2)).start();
    }

public static void main(String[] args) {
        LockDemo demo = new LockDemo();
        demo.startThreads(); // 启动线程
    }
}
```

3. **Semaphore信号量**：用于控制同时访问特定资源的线程数量。

```java
import java.util.concurrent.Semaphore;

class SemaphoreDemo {
    private Semaphore semaphore = new Semaphore(1); // 创建一个允许一次通过的信号量

public void thread1() {
        semaphore.acquire(); // 请求信号量，如果允许则获取
        try {
            System.out.println("Thread 1: Running... ");
            Thread.sleep(3000); // 模拟耗时操作
        } finally {
            semaphore.release(); // 释放信号量，允许其他线程请求
            System.out.println("Thread 1: Finished.");
        }
    }

public void thread2() {
        semaphore.acquire(); // 请求信号量，如果允许则获取
        try {
            System.out.println("Thread 2: Running... ");
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            semaphore.release(); // 释放信号量，允许其他线程请求
            System.out.println("Thread 2: Finished.");
        }
    }

public void startThreads() {
        new Thread(thread1)).start();
        new Thread(thread2)).start();
    }

public static void main(String[] args) {
        SemaphoreDemo demo = new SemaphoreDemo();
        demo.startThreads(); // 启动线程
    }
}
```

这些同步机制保证了在多线程环境下，对共享资源的访问和修改能按照预期进行。