从源代码角度看，Java中的线程同步问题-蒲公英云

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

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

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

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

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

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

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(); // 启动线程
    }
}

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

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(); // 启动线程
    }
}