上次编辑到这里，代码来自缓存 点击恢复默认模板
class DiningPhilosophers {
public:
DiningPhilosophers() {
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
}
};
cpp 解法, 执行用时: 116 ms, 内存消耗: 11.2 MB, 提交时间: 2023-10-28 10:37:51
class DiningPhilosophers {
public:
//一次性获取两把筷子
mutex mx;
DiningPhilosophers() {
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
unique_lock<mutex> lock(mx);
pickLeftFork(),pickRightFork(),eat(),putLeftFork(),putRightFork();
}
};
cpp 解法, 执行用时: 92 ms, 内存消耗: 11.1 MB, 提交时间: 2023-10-28 10:37:26
class DiningPhilosophers {
public:
mutex mu[5];
DiningPhilosophers() {
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
int left_stick = philosopher;
int right_stick = (philosopher + 1) % 5;
if(left_stick > right_stick) swap(left_stick, right_stick); // 总是先获取序号小的筷子
lock_guard<mutex> lock(mu[left_stick]);
lock_guard<mutex> lock1(mu[right_stick]);
pickLeftFork(); pickRightFork(); eat(); putLeftFork(); putRightFork();
}
};
cpp 解法, 执行用时: 96 ms, 内存消耗: 11.1 MB, 提交时间: 2023-10-28 10:37:07
class DiningPhilosophers {
public:
DiningPhilosophers() {
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
int l = philosopher;
int r = (philosopher+1)%5;
if(philosopher%2 == 0){
lock[r].lock();
lock[l].lock();
pickLeftFork();
pickRightFork();
}else{
lock[l].lock();
lock[r].lock();
pickLeftFork();
pickRightFork();
}
eat();
putRightFork();
putLeftFork();
lock[l].unlock();
lock[r].unlock();
}
private:
std::mutex lock[5];
};
cpp 解法, 执行用时: 96 ms, 内存消耗: 11.1 MB, 提交时间: 2023-10-28 10:36:36
class DiningPhilosophers {
public:
DiningPhilosophers() {
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
int l = philosopher;
int r = (philosopher+1)%5;
guid.lock();
lock[l].lock();
lock[r].lock();
pickLeftFork();
pickRightFork();
guid.unlock();
eat();
putRightFork();
putLeftFork();
lock[l].unlock();
lock[r].unlock();
}
private:
std::mutex lock[5];
std::mutex guid;
};
cpp 解法, 执行用时: 120 ms, 内存消耗: 11.5 MB, 提交时间: 2023-10-28 10:36:14
class Semaphore {
public:
Semaphore(int count = 0) : count_(count) {
}
void Set(int count){
count_ = count;
}
void Signal() {
std::unique_lock<std::mutex> lock(mutex_);
++count_;
cv_.notify_one();
}
void Wait() {
std::unique_lock<std::mutex> lock(mutex_);
while(count_ <= 0){
cv_.wait(lock);
}
--count_;
}
private:
std::mutex mutex_;
std::condition_variable cv_;
int count_;
};
class DiningPhilosophers {
public:
DiningPhilosophers() {
guid.Set(4);
}
void wantsToEat(int philosopher,
function<void()> pickLeftFork,
function<void()> pickRightFork,
function<void()> eat,
function<void()> putLeftFork,
function<void()> putRightFork) {
int l = philosopher;
int r = (philosopher+1)%5;
guid.Wait();
lock[l].lock();
lock[r].lock();
pickLeftFork();
pickRightFork();
eat();
putRightFork();
putLeftFork();
lock[r].unlock();
lock[l].unlock();
guid.Signal();
}
private:
std::mutex lock[5];
Semaphore guid;
};
java 解法, 执行用时: 9 ms, 内存消耗: 43.4 MB, 提交时间: 2023-10-28 10:35:46
class DiningPhilosophers {
//1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
private final ReentrantLock[] lockList = {new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock()};
public DiningPhilosophers() {
}
// call the run() method of any runnable to execute its code
public void wantsToEat(int philosopher,
Runnable pickLeftFork,
Runnable pickRightFork,
Runnable eat,
Runnable putLeftFork,
Runnable putRightFork) throws InterruptedException {
int leftFork = (philosopher + 1) % 5; //左边的叉子 的编号
int rightFork = philosopher; //右边的叉子 的编号
//编号为偶数的哲学家，优先拿起左边的叉子，再拿起右边的叉子
if (philosopher % 2 == 0) {
lockList[leftFork].lock(); //拿起左边的叉子
lockList[rightFork].lock(); //拿起右边的叉子
}
//编号为奇数的哲学家，优先拿起右边的叉子，再拿起左边的叉子
else {
lockList[rightFork].lock(); //拿起右边的叉子
lockList[leftFork].lock(); //拿起左边的叉子
}
pickLeftFork.run(); //拿起左边的叉子 的具体执行
pickRightFork.run(); //拿起右边的叉子 的具体执行
eat.run(); //吃意大利面 的具体执行
putLeftFork.run(); //放下左边的叉子 的具体执行
putRightFork.run(); //放下右边的叉子 的具体执行
lockList[leftFork].unlock(); //放下左边的叉子
lockList[rightFork].unlock(); //放下右边的叉子
}
}
java 解法, 执行用时: 10 ms, 内存消耗: 43.4 MB, 提交时间: 2023-10-28 10:35:27
class DiningPhilosophers {
//只允许1个哲学家就餐
private ReentrantLock pickBothForks = new ReentrantLock();
public DiningPhilosophers() {
}
// call the run() method of any runnable to execute its code
public void wantsToEat(int philosopher,
Runnable pickLeftFork,
Runnable pickRightFork,
Runnable eat,
Runnable putLeftFork,
Runnable putRightFork) throws InterruptedException {
int leftFork = (philosopher + 1) % 5; //左边的叉子 的编号
int rightFork = philosopher; //右边的叉子 的编号
pickBothForks.lock(); //进入临界区
pickLeftFork.run(); //拿起左边的叉子 的具体执行
pickRightFork.run(); //拿起右边的叉子 的具体执行
eat.run(); //吃意大利面 的具体执行
putLeftFork.run(); //放下左边的叉子 的具体执行
putRightFork.run(); //放下右边的叉子 的具体执行
pickBothForks.unlock(); //退出临界区
}
}
java 解法, 执行用时: 10 ms, 内存消耗: 43.4 MB, 提交时间: 2023-10-28 10:35:16
class DiningPhilosophers {
//1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
private final ReentrantLock[] lockList = {new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock()};
//让 1个哲学家可以 “同时”拿起2个叉子(搞个临界区)
private ReentrantLock pickBothForks = new ReentrantLock();
public DiningPhilosophers() {
}
// call the run() method of any runnable to execute its code
public void wantsToEat(int philosopher,
Runnable pickLeftFork,
Runnable pickRightFork,
Runnable eat,
Runnable putLeftFork,
Runnable putRightFork) throws InterruptedException {
int leftFork = (philosopher + 1) % 5; //左边的叉子 的编号
int rightFork = philosopher; //右边的叉子 的编号
pickBothForks.lock(); //进入临界区
lockList[leftFork].lock(); //拿起左边的叉子
lockList[rightFork].lock(); //拿起右边的叉子
pickLeftFork.run(); //拿起左边的叉子 的具体执行
pickRightFork.run(); //拿起右边的叉子 的具体执行
pickBothForks.unlock(); //退出临界区
eat.run(); //吃意大利面 的具体执行
putLeftFork.run(); //放下左边的叉子 的具体执行
putRightFork.run(); //放下右边的叉子 的具体执行
lockList[leftFork].unlock(); //放下左边的叉子
lockList[rightFork].unlock(); //放下右边的叉子
}
}
java 解法, 执行用时: 11 ms, 内存消耗: 43.5 MB, 提交时间: 2023-10-28 10:35:03
class DiningPhilosophers {
//1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
private final ReentrantLock[] lockList = {new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock(),
new ReentrantLock()};
//限制 最多只有4个哲学家去持有叉子
private Semaphore eatLimit = new Semaphore(4);
public DiningPhilosophers() {
}
// call the run() method of any runnable to execute its code
public void wantsToEat(int philosopher,
Runnable pickLeftFork,
Runnable pickRightFork,
Runnable eat,
Runnable putLeftFork,
Runnable putRightFork) throws InterruptedException {
int leftFork = (philosopher + 1) % 5; //左边的叉子 的编号
int rightFork = philosopher; //右边的叉子 的编号
eatLimit.acquire(); //限制的人数 -1
lockList[leftFork].lock(); //拿起左边的叉子
lockList[rightFork].lock(); //拿起右边的叉子
pickLeftFork.run(); //拿起左边的叉子 的具体执行
pickRightFork.run(); //拿起右边的叉子 的具体执行
eat.run(); //吃意大利面 的具体执行
putLeftFork.run(); //放下左边的叉子 的具体执行
putRightFork.run(); //放下右边的叉子 的具体执行
lockList[leftFork].unlock(); //放下左边的叉子
lockList[rightFork].unlock(); //放下右边的叉子
eatLimit.release();//限制的人数 +1
}
}
python3 解法, 执行用时: 92 ms, 内存消耗: 15.9 MB, 提交时间: 2022-08-26 15:33:24
from threading import Lock, Semaphore
class DiningPhilosophers:
def __init__(self):
self.Limit = Semaphore(4) # 限制最多4个人就餐
self.ForkLocks = [Lock() for _ in range(5)] # 叉子锁
def wantsToEat(self,
philosopher: int,
pickLeftFork: 'Callable[[], None]',
pickRightFork: 'Callable[[], None]',
eat: 'Callable[[], None]',
putLeftFork: 'Callable[[], None]',
putRightFork: 'Callable[[], None]') -> None:
# 左右叉子的编号
right_fork = philosopher
left_fork = (philosopher + 1) % 5
# 就餐人数减一
self.Limit.acquire()
# 拿起叉子
self.ForkLocks[right_fork].acquire()
self.ForkLocks[left_fork].acquire()
pickLeftFork()
pickRightFork()
eat()
putLeftFork()
putRightFork()
#放下叉子
self.ForkLocks[right_fork].release()
self.ForkLocks[left_fork].release()
#就餐人数加一
self.Limit.release()
python3 解法, 执行用时: 84 ms, 内存消耗: 15.9 MB, 提交时间: 2022-08-26 15:04:58
from threading import Lock
class DiningPhilosophers:
def __init__(self):
self.lock = Lock()
def wantsToEat(self,
philosopher: int,
pickLeftFork: 'Callable[[], None]',
pickRightFork: 'Callable[[], None]',
eat: 'Callable[[], None]',
putLeftFork: 'Callable[[], None]',
putRightFork: 'Callable[[], None]') -> None:
self.lock.acquire()
pickLeftFork()
pickRightFork()
eat()
putLeftFork()
putRightFork()
self.lock.release()
python3 解法, 执行用时: 72 ms, 内存消耗: 15.8 MB, 提交时间: 2022-08-26 15:04:25
from threading import Lock
class DiningPhilosophers:
def __init__(self):
self.ForkLocks = [Lock() for _ in range(5)] # 叉子锁
def wantsToEat(self,
philosopher: int,
pickLeftFork: 'Callable[[], None]',
pickRightFork: 'Callable[[], None]',
eat: 'Callable[[], None]',
putLeftFork: 'Callable[[], None]',
putRightFork: 'Callable[[], None]') -> None:
# 左右叉子的编号
right_fork = philosopher
left_fork = (philosopher + 1) % 5
# 偶数编号的先拿右边叉子
if philosopher % 2 == 0:
self.ForkLocks[right_fork].acquire()
self.ForkLocks[left_fork].acquire()
#奇数编号的先拿左边叉子
else:
self.ForkLocks[left_fork].acquire()
self.ForkLocks[right_fork].acquire()
pickLeftFork()
pickRightFork()
eat()
putLeftFork()
putRightFork()
self.ForkLocks[right_fork].release()
self.ForkLocks[left_fork].release()
