诡异问题：Java多线程同步问题示例

原创水深无声 2024-10-18 17:57 38阅读 0赞

在Java中，多线程的同步问题主要通过synchronized关键字、wait/notify机制和Lock接口来解决。

下面是一个简单的例子，展示了一个生产者和消费者如何通过synchronized共享资源：

```java
// 创建一个共享资源类
public class SharedResource {
    private int count = 0;

// synchronized修饰的方法
    public synchronized void increment() {
        count++;
        System.out.println("Producer incremented to " + count);
    }

// synchronized修饰的访问方法，需要重载
    public synchronized int decrement() {
        if (count > 0) {
            count--;
            System.out.println("Consumer decremented to " + count);
            return count;
        } else {
            throw new Exception("Cannot decrement from 0");
        }
    }
}

// 生产者线程
public class ProducerThread extends Thread {
    private SharedResource resource;

public ProducerThread(SharedResource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            resource.increment();
            try {
                Thread.sleep(500); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Producer finished");
    }
}

// 消费者线程
public class ConsumerThread extends Thread {
    private SharedResource resource;

public ConsumerThread(SharedResource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        while (true) {
            int count = resource.decrement();
            if (count == -1) { // 如果递减到-1，说明资源耗尽，消费者可以退出循环
                System.out.println("Consumer finished as resources depleted");
                break;
            } else {
                System.out.println("Consumer received " + count + " resources");
            }
            try {
                Thread.sleep(500); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Consumer finished");
    }
}

// 主程序，启动生产者和消费者线程
public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

// 启动生产者线程
        ProducerThread producerThread = new ProducerThread(resource);
        producerThread.start();

// 暂停一秒，模拟线程调度延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 启动消费者线程
        ConsumerThread consumerThread = new ConsumerThread(resource);
        consumerThread.start();

// 等待所有线程执行完毕
        while (!producerThread.isFinished() || !consumerThread.isFinished())) {
            try {
                Thread.sleep(1000); // 模拟线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("Program finished");
    }
}
```

这个例子中，生产者和消费者通过共享的资源进行交互。synchronized关键字保证了同一时刻只有一个线程访问资源。