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

https://www.cnblogs.com/starcrm/p/5010336.html定时线程池中scheduleWithFixedDelay和scheduleAtFixedRate

转自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

package one.threadLearn.productAndCustomer.one;

public class Hosee {
    private static Integer count = 0;
    private final Integer  FULL  = 10;
    private static String  LOCK  = "LOCK";

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == FULL) {
                        try {
                            System.out.println("仓库满了");
                            LOCK.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == 0) {
                        try {
                            System.out.println("库存空了");
                            LOCK.wait();
                        } catch (Exception e) {
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Hosee hosee = new Hosee();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
    }
}

6）用Java编程一个会导致死锁的程序，你将怎么解决？

7) 什么是原子操作，Java中的原子操作是什么？

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

9) 什么是竞争条件？你怎样发现和解决竞争？

10) 你将如何使用thread dump？你将如何分析Thread dump？

11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？

12) Java中你怎样唤醒一个阻塞的线程？

13)在Java中CycliBarriar和CountdownLatch有什么区别？

14) 什么是不可变对象，它对写并发应用有什么帮助？

15) 你在多线程环境中遇到的共同的问题是什么？你是怎么解决它的？

https://www.javazhiyin.com/category/thread