多线程面试题
两个线程一个打印奇数一个打印偶数
private int count = 0;
private final Object lock = new Object();
@Test
public void test() throws InterruptedException {
Thread even = new Thread(new TurningRunner(), "偶数");
even.start();
// 确保偶数线程线先获取到锁
Thread.sleep(1);
Thread odd = new Thread(new TurningRunner(), "奇数");
odd.start();
even.join();
odd.join();
}
class TurningRunner implements Runnable {
@Override
public void run() {
while (count <= 100) {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + ": " + count++);
lock.notifyAll();
try {
if (count <= 100) {
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}N个线程顺序循环打印从0至100
通过N个线程顺序循环打印从0至100，如给定N=3。则输出: thread0: 0 thread1: 1 thread2: 2 thread0: 3 thread1: 4
这道题很考察多线程基础。主要在于N个线程循环打印。关键在于如何控制线程的执行顺序，即唤醒特定的线程。之前通过notify()唤醒一个，notifyAll()唤醒全部，但都无法选择特定的线程执行。那如何控制控制线程有序的打印呢？
这里可以用semaphore信号量实现。设置semaphore[]数组，每个线程持有本身的信号量以及上个线程的信号量。对于三个线程abc来说，他们的last信号量对应关系为：
a.last - > semaphores[2]
b.last - > semaphores[0]
c.last - > semaphores[1]
每个线程执行时，会抢占last信号量，如a抢占 semaphores[2]，同时释放当前信号量semaphores[0]，通知等待队列中的线程b，这时线程b才能抢占通过它的last信号量：semaphores[0]，同时再释放semaphores[1]，然后唤醒c线程。。依此循环执行。
int count = 0;
Thread[] threads;
Semaphore[] semaphores;
public void print(int len) throws Exception {
threads = new Thread[len];
semaphores = new Semaphore[len];
for (int i = 0; i < len; i++) {
semaphores[i] = new Semaphore(1);
if (i != len - 1) {
semaphores[i].acquire();
}
}
for (int i = 0; i < len; i++) {
Semaphore lastSemphore = i == 0 ? semaphores[len - 1] : semaphores[i - 1];
Semaphore cur = semaphores[i];
threads[i] = new orderThread(lastSemphore, cur, "线程" + i);
threads[i].start();
}
}
class orderThread extends Thread {
/**
* 每一个线程都保存上一个线程对应的信号量
*/
Semaphore last;
/**
* 保存当前线程的信号量
*/
Semaphore cur;
orderThread(Semaphore last, Semaphore cur, String threadName) {
super(threadName);
this.last = last;
this.cur = cur;
}
/**
* 争夺上个线程的信号量，同时释放当前线程的信号量。这样唤醒下一个线程去争夺当前线程的信号量。
*/
@Override
public void run() {
while (count <= 100) {
try {
last.acquire();
//需要判断，防止线程被唤醒的时候，此时已经超过了100
if (count <= 100) {
System.out.println(Thread.currentThread().getName() + " : " + count++);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
cur.release();
}
}
}
}
@Test
public void test() throws Exception {
print(3);
Thread.sleep(3000);
}synchornized锁住的是什么
synchronized(obj) ，obj非static，锁的是实例对象，不是代码。当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。
synchronized(xx.class)锁的是class对象，全局性的，相当于锁住了代码块。
https://blog.csdn.net/xiao__gui/article/details/8188833
阻塞队列实现生产者消费者模型
//生产者
public static class Producer implements Runnable {
private final BlockingQueue<Integer> blockingQueue;
private volatile boolean flag;
private Random random;
public Producer(BlockingQueue<Integer> blockingQueue) {
this.blockingQueue = blockingQueue;
flag = false;
random = new Random();
}
public void run() {
while (!flag) {
int info = random.nextInt(100);
try {
blockingQueue.put(info);
System.out.println(Thread.currentThread().getName() + " produce " + info);
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void shutDown() {
flag = true;
}
}
//消费者
public static class Consumer implements Runnable {
private final BlockingQueue<Integer> blockingQueue;
private volatile boolean flag;
public Consumer(BlockingQueue<Integer> blockingQueue) {
this.blockingQueue = blockingQueue;
}
public void run() {
while (!flag) {
int info;
try {
info = blockingQueue.take();
System.out.println(Thread.currentThread().getName() + " consumer " + info);
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public void shutDown() {
flag = true;
}
}
public static void main(String[] args) {
BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>(10);
Producer producer = new Producer(blockingQueue);
Consumer consumer = new Consumer(blockingQueue);
//创建5个生产者，5个消费者
for (int i = 0; i < 10; i++) {
if (i < 5) {
new Thread(producer, "producer" + i).start();
} else {
new Thread(consumer, "consumer" + (i - 5)).start();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
producer.shutDown();
consumer.shutDown();
}手写生产者消费者模型
Integer count = 0;
Object obj = new Object();
private void produce() {
while (true) {
synchronized (obj) {
while (count == 10) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count++;
System.out.println("生产后count = " + count);
obj.notifyAll();
}
}
}
private void consume() {
while (true) {
synchronized (obj) {
while (count <= 0) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
System.out.println("消费后count = " + count);
obj.notifyAll();
}
}
}
@Test
public void test() throws InterruptedException {
Thread t1 = new Thread(()->produce());
Thread t2 = new Thread(()->consume());
t1.start();
t2.start();
t1.join();
t2.join();
}Last updated
Was this helpful?