一个常见的例子是当线程试图获取一个被其他线程持有的锁时，它会被阻塞。举个java代码例子

当一个线程试图获取一个被其他线程持有的锁时，它会被阻塞。以下是一个Java代码例子：

public class LockExample {
    private final Object lock = new Object();

    public void doSomething() {
        synchronized (lock) {
            // 代码块
        }
    }
}

在这个例子中，`doSomething()`方法使用`synchronized`关键字来获取一个锁。如果另一个线程已经持有了这个锁，那么当前线程将被阻塞，直到锁被释放。

相关问题

编写一个java程序 两个线程同时执行，一个读Map，一个写Map

在Java中编写一个包含两个线程同时操作Map的程序，通常我们会使用`synchronized`关键字来保证线程安全，因为Map不是线程安全的。下面是一个简单的示例，假设我们有一个`MyMap`类，它有读取(`read`)和写入(`write`)方法：

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

public class MyMap {
    private Map<String, String> map = new HashMap<>();
    private Lock lock = new ReentrantLock(); // 使用锁

    public void write(String key, String value) {
        lock.lock();
        try {
            map.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    public String read(String key) {
        lock.lock();
        try {
            return map.get(key);
        } finally {
            lock.unlock();
        }
    }
}

// 主线程启动两个线程
public class Main {
    public static void main(String[] args) {
        MyMap myMap = new MyMap();

        Thread writerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                String key = "Key" + i;
                String value = "Value" + i;
                myMap.write(key, value);
            }
        });

        Thread readerThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                String key = "KeyToRead";
                System.out.println("Reading: " + myMap.read(key));
            }
        });

        writerThread.start();
        readerThread.start();

        // 等待一段时间让两个线程运行，然后停止读者线程
        try {
            Thread.sleep(2000);
            readerThread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        writerThread.join(); // 确保写入完成
    }
}

在这个例子中，`write`方法会获取锁并更新Map，而`read`方法也是如此。当两个线程试图同时修改Map时，它们会被阻塞，直到当前持有锁的线程释放锁。