求一个 Java 面试题的最佳实践

[Cbdy]

三个线程，分别输出 a 、b 、c，各输出 100 次，要求按 abc 的顺序输出

期待输出为：abcabcabcabc...

[Vendettar]

@ocean1477 咋不对呢 我这里输出是对的啊..

[ocean1477]

@Vendettar 这个是无法保证顺序的，1，2，3 三个线程可以同时进，争抢一个锁。

[Vendettar]

@ocean1477 公平锁不会争抢 你输出一下试试 顺序不会乱

[ocean1477]

@Vendettar 我这会试了下，会乱的，多试几次。
Thread-0:a
Thread-0:a
Thread-0:a
Thread-0:a
Thread-0:a
Thread-1:b
Thread-2:c
Thread-0:a
Thread-1:b
Thread-2:c
Thread-0:a
Thread-1:b
Thread-2:c
Thread-0:a
Thread-1:b

[ocean1477]

@Vendettar 看来老兄要重新看下公平锁了，公平锁≠顺序

[Vendettar]

@ocean1477 热 我试出来了 的确会乱

[ocean1477]

@Vendettar 哈哈，我无意指出，抱歉。

[ssynhtn]

用三个 Semaphore 就行了吧

[Vendettar]

@ocean1477 感谢指出

[sczero]

public static void main(String[] args) throws InterruptedException {
final AtomicReference<String> tag = new AtomicReference<>("a");
final int total = 100;
new Thread(() -> {
int count = 0;
while (count < total) {
if (tag.get().equals("a")) {
System.out.print("a");
tag.set("b");
count++;
}
}
}).start();
new Thread(() -> {
int count = 0;
while (count < total) {
if (tag.get().equals("b")) {
System.out.print("b");
tag.set("c");
count++;
}
}
}).start();
new Thread(() -> {
int count = 0;
while (count < total) {
if (tag.get().equals("c")) {
System.out.println("c");
tag.set("a");
count++;
}
}
}).start();
}

[ssynhtn]

public static void main(String[] args) {
Semaphore[] res = {
new Semaphore(1),
new Semaphore(0),
new Semaphore(0),
};

for (int i = 0; i < 3; i++) {
Semaphore current = res[i];
Semaphore next = res[(i + 1) % 3];
final char ch = (char) (i + 'a');
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 100; j++) {
try {
current.acquire();
System.out.print(ch);
next.release();
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}
}).start();
}

}

[Cyron]

简单公平锁实现
```
public class ReentrantLockDemo implements Runnable {

private static ReentrantLock lock = new ReentrantLock(true);

private String content;

public ReentrantLockDemo(String content) {
this.content = content;
}

@Override
public void run() {
while (true) {
try {
lock.lock();
System.out.println(content);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}

public static void main(String[] args) {
ReentrantLockDemo a = new ReentrantLockDemo("a");
ReentrantLockDemo b = new ReentrantLockDemo("b");
ReentrantLockDemo c = new ReentrantLockDemo("c");
Thread threadA = new Thread(a);
Thread threadB = new Thread(b);
Thread threadC = new Thread(c);
threadA.start();
threadB.start();
threadC.start();
}
}
```

[zzh7982]

不用加锁，join 就行了,刚测试了一把 没问题

https://gist.github.com/zzh7982/249883f379b50c5ae50eacd48736b5e2

[kikione]

我想到两个方案，第一个是加锁。 第二个是 join，b 等 a ,c 等 a 。

[sczero]

@zzh7982 新建了 300 个线程......至于吗....

[zzh7982]

@sczero 啊..这... 300 个线程都能控制顺序 这不显得水平高吗[dog]

[kikione]

for (int i=0;i<100;i++){
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
Thread3 thread3 = new Thread3();
thread1.start();
thread1.join();
thread2.start();
thread2.join();
thread3.start();
}

[sampeng]

都是有锁方案啊。。我提一个无锁和竞争的方案
三个队列。分别收 a，b，c 。
输出就是轮询这 3 个队列就好了。。一定都是有序的

[johnson666]

原子变量

public class Test {
public static void main(String[] args) {
AtomicInteger at = new AtomicInteger();
for (int i = 0; i < 3; i++) {
MyThread t = new MyThread(at, i);
t.start();
}
}
}

class MyThread extends Thread {
private AtomicInteger at;
private int index;

public MyThread(AtomicInteger at, int index) {
this.at = at;
this.index = index;
}

@Override
public void run() {
while(true) {
if(at.get() % 3 == index) {
System.out.print((char)('a' + index));
at.incrementAndGet();
}
}
}
}

[Youen]

https://leetcode.com/problems/fizz-buzz/