Skip to content

Commit 3480494

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1115
No.1115.Print FooBar Alternately
1 parent 599c9b5 commit 3480494

File tree

5 files changed

+127
-84
lines changed

5 files changed

+127
-84
lines changed

‎solution/1100-1199/1115.Print FooBar Alternately/README.md

Lines changed: 49 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,17 @@ class FooBar {
6363

6464
<!-- 这里可写通用的实现逻辑 -->
6565

66-
两把锁分别对应 `foo` 和 `bar`，先把 `bar` 锁住，确保第一个输出的是 `foo`
66+
**方法一：多线程 + 信号量**
67+
68+
我们用两个信号量 $f$ 和 $b$ 来控制两个线程的执行顺序，其中 $f$ 初始值为 $1$，而 $b$ 初始值为 $0$，表示线程 $A$ 先执行。
69+
70+
当线程 $A$ 执行时，首先会执行 $f$ 的 $acquire$ 操作，此时 $f$ 的值变为 $0$，线程 $A$ 获得了 $f$ 的使用权，可以执行 $foo$ 函数，然后执行 $b$ 的 $release$ 操作，此时 $b$ 的值变为 $1$，线程 $B$ 获得了 $b$ 的使用权，可以执行 $bar$ 函数。
71+
72+
当线程 $B$ 执行时，首先会执行 $b$ 的 $acquire$ 操作，此时 $b$ 的值变为 $0$，线程 $B$ 获得了 $b$ 的使用权，可以执行 $bar$ 函数，然后执行 $f$ 的 $release$ 操作，此时 $f$ 的值变为 $1$，线程 $A$ 获得了 $f$ 的使用权，可以执行 $foo$ 函数。
73+
74+
因此，我们只需要循环 $n$ 次，每次执行 $foo$ 和 $bar$ 函数时，先执行 $acquire$ 操作，再执行 $release$ 操作即可。
75+
76+
时间复杂度 $O(n)$，空间复杂度 $O(1)$。
6777

6878
<!-- tabs:start -->
6979

@@ -72,24 +82,28 @@ class FooBar {
7282
<!-- 这里可写当前语言的特殊实现逻辑 -->
7383

7484
```python
85+
from threading import Semaphore
86+
87+
7588
class FooBar:
7689
def __init__(self, n):
7790
self.n = n
78-
self.fooLock = threading.Lock()
79-
self.barLock = threading.Lock()
80-
self.barLock.acquire()
91+
self.f = Semaphore(1)
92+
self.b = Semaphore(0)
8193

82-
def foo(self, printFoo: 'Callable[[], None]') -> None:
83-
for i in range(self.n):
84-
self.fooLock.acquire()
94+
def foo(self, printFoo: "Callable[[], None]") -> None:
95+
for _ in range(self.n):
96+
self.f.acquire()
97+
# printFoo() outputs "foo". Do not change or remove this line.
8598
printFoo()
86-
self.barLock.release()
99+
self.b.release()
87100

88-
def bar(self, printBar: 'Callable[[], None]') -> None:
89-
for i in range(self.n):
90-
self.barLock.acquire()
101+
def bar(self, printBar: "Callable[[], None]") -> None:
102+
for _ in range(self.n):
103+
self.b.acquire()
104+
# printBar() outputs "bar". Do not change or remove this line.
91105
printBar()
92-
self.fooLock.release()
106+
self.f.release()
93107
```
94108

95109
### **Java**
@@ -99,26 +113,28 @@ class FooBar:
99113
```java
100114
class FooBar {
101115
private int n;
102-
private final Semaphore fooSem = new Semaphore(1);
103-
private final Semaphore barSem = new Semaphore(0);
116+
private Semaphore f = new Semaphore(1);
117+
private Semaphore b = new Semaphore(0);
104118

105119
public FooBar(int n) {
106120
this.n = n;
107121
}
108122

109123
public void foo(Runnable printFoo) throws InterruptedException {
110124
for (int i = 0; i < n; i++) {
111-
fooSem.acquire();
112-
printFoo.run();
113-
barSem.release();
125+
f.acquire(1);
126+
// printFoo.run() outputs "foo". Do not change or remove this line.
127+
printFoo.run();
128+
b.release(1);
114129
}
115130
}
116131

117132
public void bar(Runnable printBar) throws InterruptedException {
118133
for (int i = 0; i < n; i++) {
119-
barSem.acquire();
120-
printBar.run();
121-
fooSem.release();
134+
b.acquire(1);
135+
// printBar.run() outputs "bar". Do not change or remove this line.
136+
printBar.run();
137+
f.release(1);
122138
}
123139
}
124140
}
@@ -127,30 +143,35 @@ class FooBar {
127143
### **C++**
128144

129145
```cpp
146+
#include <semaphore.h>
147+
130148
class FooBar {
131149
private:
132150
int n;
133-
mutex fooMu, barMu;
151+
sem_t f, b;
134152

135153
public:
136154
FooBar(int n) {
137155
this->n = n;
138-
barMu.lock();
156+
sem_init(&f, 0, 1);
157+
sem_init(&b, 0, 0);
139158
}
140159

141160
void foo(function<void()> printFoo) {
142161
for (int i = 0; i < n; i++) {
143-
fooMu.lock();
144-
printFoo();
145-
barMu.unlock();
162+
sem_wait(&f);
163+
// printFoo() outputs "foo". Do not change or remove this line.
164+
printFoo();
165+
sem_post(&b);
146166
}
147167
}
148168

149169
void bar(function<void()> printBar) {
150170
for (int i = 0; i < n; i++) {
151-
barMu.lock();
152-
printBar();
153-
fooMu.unlock();
171+
sem_wait(&b);
172+
// printBar() outputs "bar". Do not change or remove this line.
173+
printBar();
174+
sem_post(&f);
154175
}
155176
}
156177
};

‎solution/1100-1199/1115.Print FooBar Alternately/README_EN.md

Lines changed: 38 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -63,51 +63,57 @@ class FooBar {
6363
### **Python3**
6464

6565
```python
66+
from threading import Semaphore
67+
68+
6669
class FooBar:
6770
def __init__(self, n):
6871
self.n = n
69-
self.fooLock = threading.Lock()
70-
self.barLock = threading.Lock()
71-
self.barLock.acquire()
72+
self.f = Semaphore(1)
73+
self.b = Semaphore(0)
7274

73-
def foo(self, printFoo: 'Callable[[], None]') -> None:
74-
for i in range(self.n):
75-
self.fooLock.acquire()
75+
def foo(self, printFoo: "Callable[[], None]") -> None:
76+
for _ in range(self.n):
77+
self.f.acquire()
78+
# printFoo() outputs "foo". Do not change or remove this line.
7679
printFoo()
77-
self.barLock.release()
80+
self.b.release()
7881

79-
def bar(self, printBar: 'Callable[[], None]') -> None:
80-
for i in range(self.n):
81-
self.barLock.acquire()
82+
def bar(self, printBar: "Callable[[], None]") -> None:
83+
for _ in range(self.n):
84+
self.b.acquire()
85+
# printBar() outputs "bar". Do not change or remove this line.
8286
printBar()
83-
self.fooLock.release()
87+
self.f.release()
8488
```
8589

8690
### **Java**
8791

8892
```java
8993
class FooBar {
9094
private int n;
91-
private final Semaphore fooSem = new Semaphore(1);
92-
private final Semaphore barSem = new Semaphore(0);
95+
private Semaphore f = new Semaphore(1);
96+
private Semaphore b = new Semaphore(0);
9397

9498
public FooBar(int n) {
9599
this.n = n;
96100
}
97101

98102
public void foo(Runnable printFoo) throws InterruptedException {
99103
for (int i = 0; i < n; i++) {
100-
fooSem.acquire();
101-
printFoo.run();
102-
barSem.release();
104+
f.acquire(1);
105+
// printFoo.run() outputs "foo". Do not change or remove this line.
106+
printFoo.run();
107+
b.release(1);
103108
}
104109
}
105110

106111
public void bar(Runnable printBar) throws InterruptedException {
107112
for (int i = 0; i < n; i++) {
108-
barSem.acquire();
109-
printBar.run();
110-
fooSem.release();
113+
b.acquire(1);
114+
// printBar.run() outputs "bar". Do not change or remove this line.
115+
printBar.run();
116+
f.release(1);
111117
}
112118
}
113119
}
@@ -116,30 +122,35 @@ class FooBar {
116122
### **C++**
117123

118124
```cpp
125+
#include <semaphore.h>
126+
119127
class FooBar {
120128
private:
121129
int n;
122-
mutex fooMu, barMu;
130+
sem_t f, b;
123131

124132
public:
125133
FooBar(int n) {
126134
this->n = n;
127-
barMu.lock();
135+
sem_init(&f, 0, 1);
136+
sem_init(&b, 0, 0);
128137
}
129138

130139
void foo(function<void()> printFoo) {
131140
for (int i = 0; i < n; i++) {
132-
fooMu.lock();
133-
printFoo();
134-
barMu.unlock();
141+
sem_wait(&f);
142+
// printFoo() outputs "foo". Do not change or remove this line.
143+
printFoo();
144+
sem_post(&b);
135145
}
136146
}
137147

138148
void bar(function<void()> printBar) {
139149
for (int i = 0; i < n; i++) {
140-
barMu.lock();
141-
printBar();
142-
fooMu.unlock();
150+
sem_wait(&b);
151+
// printBar() outputs "bar". Do not change or remove this line.
152+
printBar();
153+
sem_post(&f);
143154
}
144155
}
145156
};

‎solution/1100-1199/1115.Print FooBar Alternately/Solution.cpp

Lines changed: 14 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,32 @@
1+
#include <semaphore.h>
2+
13
class FooBar {
24
private:
35
int n;
4-
mutex fooMu, barMu;
6+
sem_t f, b;
57

68
public:
79
FooBar(int n) {
810
this->n = n;
9-
barMu.lock();
11+
sem_init(&f, 0, 1);
12+
sem_init(&b, 0, 0);
1013
}
1114

1215
void foo(function<void()> printFoo) {
1316
for (int i = 0; i < n; i++) {
14-
fooMu.lock();
15-
printFoo();
16-
barMu.unlock();
17+
sem_wait(&f);
18+
// printFoo() outputs "foo". Do not change or remove this line.
19+
printFoo();
20+
sem_post(&b);
1721
}
1822
}
1923

2024
void bar(function<void()> printBar) {
2125
for (int i = 0; i < n; i++) {
22-
barMu.lock();
23-
printBar();
24-
fooMu.unlock();
26+
sem_wait(&b);
27+
// printBar() outputs "bar". Do not change or remove this line.
28+
printBar();
29+
sem_post(&f);
2530
}
2631
}
27-
};
32+
};

‎solution/1100-1199/1115.Print FooBar Alternately/Solution.java

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,27 @@
11
class FooBar {
22
private int n;
3-
private final Semaphore fooSem = new Semaphore(1);
4-
private final Semaphore barSem = new Semaphore(0);
3+
private Semaphore f = new Semaphore(1);
4+
private Semaphore b = new Semaphore(0);
55

66
public FooBar(int n) {
77
this.n = n;
88
}
99

1010
public void foo(Runnable printFoo) throws InterruptedException {
1111
for (int i = 0; i < n; i++) {
12-
fooSem.acquire();
13-
printFoo.run();
14-
barSem.release();
12+
f.acquire(1);
13+
// printFoo.run() outputs "foo". Do not change or remove this line.
14+
printFoo.run();
15+
b.release(1);
1516
}
1617
}
1718

1819
public void bar(Runnable printBar) throws InterruptedException {
1920
for (int i = 0; i < n; i++) {
20-
barSem.acquire();
21-
printBar.run();
22-
fooSem.release();
21+
b.acquire(1);
22+
// printBar.run() outputs "bar". Do not change or remove this line.
23+
printBar.run();
24+
f.release(1);
2325
}
2426
}
25-
}
27+
}

‎solution/1100-1199/1115.Print FooBar Alternately/Solution.py

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,22 @@
1+
from threading import Semaphore
2+
3+
14
class FooBar:
25
def __init__(self, n):
36
self.n = n
4-
self.fooLock = threading.Lock()
5-
self.barLock = threading.Lock()
6-
self.barLock.acquire()
7+
self.f = Semaphore(1)
8+
self.b = Semaphore(0)
79

8-
def foo(self, printFoo: 'Callable[[], None]') -> None:
9-
for i in range(self.n):
10-
self.fooLock.acquire()
10+
def foo(self, printFoo: "Callable[[], None]") -> None:
11+
for _ in range(self.n):
12+
self.f.acquire()
13+
# printFoo() outputs "foo". Do not change or remove this line.
1114
printFoo()
12-
self.barLock.release()
15+
self.b.release()
1316

14-
def bar(self, printBar: 'Callable[[], None]') -> None:
15-
for i in range(self.n):
16-
self.barLock.acquire()
17+
def bar(self, printBar: "Callable[[], None]") -> None:
18+
for _ in range(self.n):
19+
self.b.acquire()
20+
# printBar() outputs "bar". Do not change or remove this line.
1721
printBar()
18-
self.fooLock.release()
22+
self.f.release()

0 commit comments

Comments
 (0)