哥妞 海淀山后有哥妞

并发编程常见面试题以及答案

2021-03-13

什么是不可变对象,它对写并发应用有什么帮助?

用 Java 编程一个会导致死锁的程序,你将怎么解决?

1、现在有 T1、T2、T3 三个线程,你怎样保证 T2 在 T1 执行完后执行,T3 在 T2 执行完后执行?

考察 Thread.join,还有其他concurrent包下工具类的了解。

方法一:可以使用 join 方法实现等待;

方法二:可以使用 CompletableFuture 的 thenCombine 方法

public class TestOrder {

    public static void main(String[] args) {
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread 1");
            }
        };
        thread1.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread2 = new Thread() {
            @Override
            public void run() {
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread 2");
            }
        };
        thread2.start();
        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread3 = new Thread() {
            @Override
            public void run() {
                try {
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread 3");
            }
        };
        thread3.start();

    }
}

2、在 java 中 wait 和 sleep 方法的不同?

sleep 是 Thread 类的方法;wait是 Object 的方法。

此外,wait 期间会释放锁,sleep期间会持有锁。wait通常用于线程交互,sleep一般用于暂停执行。

3、什么是竞争条件?你怎样发现和解决竞争?

在并发编程中,由于不恰当的执行时序而出现不正确的结果是一种非常重要的情况,它的正式名字就叫竞态条件。

或者可以说:当某个计算的正确性取决于多个线程的交替执行时序时,那么就会发生竞态条件。

换句话说,就是正确的结果取决于运气。

发生场景:最常见的场景就是 “先检查再执行”

例子:

public ExpensiveObject getInstance() {
    // 先检查后执行,这种场景下会发生竞态条件
    if (instance == null) {
        instance = new ExpensiveObject();
    }
    return instance;
}

4、Java 中你怎样停止或者取消一个线程?

如果不是因为IO阻塞,常见的

https://blog.csdn.net/Prepared/article/details/114164117

5、什么是不可变对象,它对写并发应用有什么帮助?

满足以下条件时,对象才是不可变的:

1、对象创建以后其状态就不能修改;

2、对象的所有域都是final类型;

3、对象是正确创建的(在对象的创建期间,this引用没有逸出)

说明:即使对象中的所有的域都是final类型的,这个对象也仍然是可变的。

6、用 Java 编程一个会导致死锁的程序,你将怎么解决?

两个线程,线程A持有资源C,等待持有资源D;线程B持有资源D,等待持有资源C。

一个常见的场景是转账:银行A,持有转入账户,等待持有转出账户;银行B,持有转出账户,等待持有转入账户。

以下是一个例子,互相持有对方持有的锁

public class Test1001LeftRightDeadLock {

    private final Object left = new Object();

    private final Object right = new Object();

    public void leftRight() {
        synchronized (left) {
            doSomething();
        }
    }

    private void doSomething() {
    }

    private void doSomethingElse() {
    }

    public void rightLeft() {
        synchronized (right) {
            doSomethingElse();
        }
    }
}

7、什么是原子操作,Java 中的原子操作是什么?

假定有两个操作A和B,如果从执行A的线程来看,当另一个线程执行B时,要么将B全部执行完,要不完全不执行B,那么A和B对彼此来说就是原子的。原子操作是指,对于访问同一个状态的所有操作(包括该操作本身)来说,这个操作是一个以原子方式执行的操作,

举例:count++

不是原子操作,先要获取count的值,然后执行+1的操作。

其中获取值是原子操作。

8、Java 中的 volatile 关键是什么作用?怎样使用它?在 Java 中它跟 synchronized 方法有什么不同?

volatile 有两个作用,一个是禁止指令重排序,另一是保证可见性。

synchronized 除了这两个作用之外,还可以锁住资源,限制资源同时只能有一个线程访问。

9、为什么我们调用 start()方法时会执行 run()方法,为什么我们不能直接调用 run()方法?

当你调用 start()方法时你将创建新的线程,并且执行在 run()方法里的代码。 但是如果你直接调用 run()方法,它不会创建新的线程也不会执行调用线程的代码。

10、用 Java 实现阻塞队列

入队操作,如果队列已满,需要等待队列不满,使用await方法;入队之后,通知出队线程;

出队操作,如果队列为空,需要等待队列不空,使用await方法;出队之后,通知入队线程;

public class BlockedQueue<T> {

	final Lock lock = new ReentrantLock();
	// 条件变量:队列不满
	final Condition notFull = lock.newCondition();
	// 条件变量:队列不空
	final Condition notEmpty = lock.newCondition();

	// 入队
	void enq(T x) {
		lock.lock();
		try {
			//  队列已满
			boolean flag = true;
			while (flag) {
				// 等待队列不满
				notFull.await();
			}
			// 省略入队操作...
			//入队后,通知可出队
			notEmpty.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	// 出队
	void deq() {
		lock.lock();
		try {
			//  队列已空
			boolean flag = true;
			while (flag) {
				// 等待队列不空
				notEmpty.await();
			}
			// 省略出队操作...
			//出队后,通知可入队
			notFull.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

代码地址:https://github.com/prepared48/Java-learning.git


1分也是爱


微信扫描二维码,关注公众号 (转载本站文章请注明作者和出处 哥妞-geniu)

Similar Posts

评论