并发系统面试题

1.sleep和wait方法的区别?

  （1）sleep是Thread类的方法，并且是有参方法

           wait是Object类的方法，可以有参可以无参

  （2）sleep是当前线程休眠，让出cpu，不释放锁

           wait是当前线程等待，释放锁

   （3）使用上区别：sleep()属于static 方法，wait则不是；wait必须和notify或者notifyAll一起使用。

sleep方法原理：

     java中代码：

//注意是native方法，本地方法
public static native void sleep(long millis) throws InterruptedException;

   底层主要是通过内核态的定时器实现。

  wait()方法：

public final void wait() throws InterruptedException {
        wait(0);
    }
 public final native void wait(long timeout) throws InterruptedException;

底层原理主要是通过waitSet集合实现的，wait之后进入的是waitSet集合，notify之后从集合中拿出来放入cxq双向队列中。这个集合也就是我们通常所说的任务，也就是锁的内容。

2.什么是进程、线程，有什么区别？

       进程是资源分配的基本单位

       线程是cpu调度和分配（程序执行的最小单位）的最小单位。

3.如何让t1,t2,t3交替执行？

    （1）使用join()方法

          注意点:顺序不能变，变了结果不对。此方式不推荐

public static void main(String[] args) throws InterruptedException {
        Thread a = new Thread(()->{
            System.out.println("a");
        });
        Thread b = new Thread(()->{
            System.out.println("b");
        });
        Thread c = new Thread(()->{
            System.out.println("c");
        });
        a.start();
        a.join();
        b.start();
        b.join();
        c.start();
        c.join();
    }

 （2）Excetors.newSingleThreadExecutor

SingleThreadExecutor(单线程池) 利用了队列的先进先出

private static void testSingleThreadPool() {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    List<String> threadNameList = Arrays.asList("A", "B", "C");
    for (int i = 0; i < 3; i++) {
        executor.execute(new ThreadTest(threadNameList.get(i)));
    }
    executor.shutdown();
}

    (3)object.wait/notify(等待通知)

     

Object myLock1 = new Object();
    Object myLock2 = new Object();

    /**
     * 为什么要加这两个标识状态?
     * 如果没有状态标识，当t1已经运行完了t2才运行，t2在等待t1唤醒导致t2永远处于等待状态
     */
    Boolean t1Run = false;
    Boolean t2Run = false;

    public  void testWaitNotify() {
        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (myLock1){
                    System.out.println("a");
                    t1Run = true;
                    myLock1.notify();
                }
            }
        });
        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (myLock1){
                    try {
                        if(!t1Run){
                            myLock1.wait();
                        }
                        synchronized (myLock2){
                            System.out.println("b");
                            myLock2.notify();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread c = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (myLock2){
                    try {
                        if(!t2Run){
                            myLock2.wait();
                        }
                        System.out.println("c");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        a.start();
        b.start();
        c.start();
    }

 (4)使用线程的 Condition(条件变量) 方法

(5). 使用线程的 CountDownLatch(倒计数) 方法 

    2个CountDonwLatch进行执行，每个初始化为1

（6）使用 CyclicBarrier (回环栅栏)实现线程按顺序执行

         2个CyclicBarrier 每个设置成2

  (7).使用线程的 Sephmore(信号量) 实现线程按顺序执行
       2个信号量