15个顶级多线程面试题及答案

最新推荐文章于 2022-07-13 23:09:00 发布

weixin_30381317

最新推荐文章于 2022-07-13 23:09:00 发布

阅读量380

点赞数

原文链接：http://www.cnblogs.com/woainixxx/p/10856714.html

版权

转自https://www.cnblogs.com/huajiezh/p/5790942.html

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

这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。

不错的链接讲解链接x=https://blog.csdn.net/u010983881/article/details/80257703

有趣的是，第一个运行结果大概率是这样的。说明没主线程会抢吗，。，

第二个运行结果是这样的

猜想是这样的：指令做了重新排序，或者看看源码去，现在能力弱鸡，还是先别看。以上两张图说明会把主线程先运行完再去运行子线程的东西。从下面的运行看，是和主线程抢的太少了，线程多的时候，嘿嘿主线程就多挂会把。

而join会把当前正在被调用的线程阻塞直到调用的线程运行完毕。当设置了join(time)时间的时候，time过了，不管threadA有没有执行完都会回到主线程.如下，上面join(500)的结果

所以T1-->T2-->T3,

右图是代码，开始是无序执行的，解开注释代码后，就是有序的了。join拿到主线程，让自己先运行完，然后回到主线程。

外记，创建线程用的是链接中显示创建，阿里给的提示

2 在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？

lock锁参考1 　　　　https://www.cnblogs.com/dolphin0520/p/3923167.html

多个用户读，一个用户写： https://www.cnblogs.com/XinHuai/p/6830790.html

外记 synchronized和ReentrantLock都是可重入锁

总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断； lock的优势1

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。优势2

　　5）Lock可以提高多个线程进行读操作的效率。　　优势3

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

3)在java中wait和sleep方法的不同？

最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。

4）用Java实现阻塞队列

https://www.cnblogs.com/huojg-21442/p/7119727.html 阻塞队列实现1

https://www.cnblogs.com/dolphin0520/p/3932906.html 心情不爽，没看了

5）用Java写代码来解决生产者——消费者问题。

http://www.cnblogs.com/moongeek/p/7631447.html

https://www.cnblogs.com/jiangyang/p/6007030.html

1 wait/notify

 1 package one.threadLearn.productAndCustomer.one;
 2 
 3 public class Hosee {
 4     private static Integer count = 0;
 5     private final Integer  FULL  = 10;
 6     private static String  LOCK  = "LOCK";
 7 
 8     class Producer implements Runnable {
 9         @Override
10         public void run() {
11             for (int i = 0; i < 10; i++) {
12                 try {
13                     Thread.sleep(3000);
14                 } catch (Exception e) {
15                     e.printStackTrace();
16                 }
17                 synchronized (LOCK) {
18                     while (count == FULL) {
19                         try {
20                             System.out.println("仓库满了");
21                             LOCK.wait();
22                         } catch (Exception e) {
23                             e.printStackTrace();
24                         }
25                     }
26                     count++;
27                     System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
28                     LOCK.notifyAll();
29                 }
30             }
31         }
32     }
33 
34     class Consumer implements Runnable {
35         @Override
36         public void run() {
37             for (int i = 0; i < 10; i++) {
38                 try {
39                     Thread.sleep(3000);
40                 } catch (InterruptedException e1) {
41                     e1.printStackTrace();
42                 }
43                 synchronized (LOCK) {
44                     while (count == 0) {
45                         try {
46                             System.out.println("库存空了");
47                             LOCK.wait();
48                         } catch (Exception e) {
49                         }
50                     }
51                     count--;
52                     System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
53                     LOCK.notifyAll();
54                 }
55             }
56         }
57     }
58 
59     public static void main(String[] args) throws Exception {
60         Hosee hosee = new Hosee();
61         new Thread(hosee.new Producer()).start();
62         new Thread(hosee.new Producer()).start();
63         new Thread(hosee.new Consumer()).start();
64         new Thread(hosee.new Producer()).start();
65         new Thread(hosee.new Consumer()).start();
66         new Thread(hosee.new Producer()).start();
67         new Thread(hosee.new Consumer()).start();
68         new Thread(hosee.new Producer()).start();
69         new Thread(hosee.new Consumer()).start();
70     }
71 }