面试题答案
一键面试- 锁机制
- 原理:使用锁可以确保在同一时间只有一个线程能够访问和修改字典。当一个线程获取到锁后,其他线程必须等待锁被释放才能进行操作,从而避免竞态条件。
- 示例代码(Python):
import threading
my_dict = {}
lock = threading.Lock()
def update_dict(new_data):
global my_dict
with lock:
my_dict.update(new_data)
data_list = [{"a": 1}, {"b": 2}, {"c": 3}]
threads = []
for data in data_list:
thread = threading.Thread(target = update_dict, args=(data,))
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
print(my_dict)
- 线程安全的数据结构
- 原理:一些编程语言提供了线程安全的数据结构,例如Python中的
collections.ConcurrentDict
(在Python 3.7及以上版本中没有直接的ConcurrentDict
,但multiprocessing.Manager().dict()
可以在多进程(类似多线程场景需求)中提供线程安全字典操作)。这些数据结构内部通过特殊的机制(如内部锁的精细化管理等)来确保多个线程同时操作时的数据一致性。 - 示例代码(Python使用
multiprocessing.Manager().dict()
模拟多线程场景下的线程安全字典):
- 原理:一些编程语言提供了线程安全的数据结构,例如Python中的
import multiprocessing
import threading
def update_dict(new_data, shared_dict):
shared_dict.update(new_data)
data_list = [{"a": 1}, {"b": 2}, {"c": 3}]
manager = multiprocessing.Manager()
my_dict = manager.dict()
threads = []
for data in data_list:
thread = threading.Thread(target = update_dict, args=(data, my_dict))
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
print(dict(my_dict))
在Java中,可以使用ConcurrentHashMap
,它允许多个线程同时读,并且对写操作进行了优化,减少锁的粒度。示例代码如下:
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ConcurrentDictUpdate {
private static ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
public static void updateDict(String key, Integer value) {
concurrentHashMap.put(key, value);
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
executorService.submit(() -> updateDict("a", 1));
executorService.submit(() -> updateDict("b", 2));
executorService.submit(() -> updateDict("c", 3));
executorService.shutdown();
while (!executorService.isTerminated()) {
}
System.out.println(concurrentHashMap);
}
}