面试知识点三：Java多线程

标签：shutdown   字符串   tran   alt   中断   异常抛出   calling   new   fixed   

35.并行和并发有什么区别？

36.线程和进程的区别？

37.守护线程是什么？

38.创建线程有哪几种方式？

39.说一下 runnable 和 callable 有什么区别？

40.线程有哪些状态？

41.sleep() 和 wait() 有什么区别？

42.notify()和 notifyAll()有什么区别？

43.线程的 run()和 start()有什么区别？

44.创建线程池有哪几种方式？

45.线程池都有哪些状态？

46.线程池中 submit()和 execute()方法有什么区别？

47.在 java 程序中怎么保证多线程的运行安全？

48.多线程锁的升级原理是什么？

49.什么是死锁？

50.怎么防止死锁？

51.ThreadLocal 是什么？有哪些使用场景？

52.说一下 synchronized 底层实现原理？

53.synchronized 和 volatile 的区别是什么？

54.synchronized 和 Lock 有什么区别？

55.synchronized 和 ReentrantLock 区别是什么？

56.说一下 atomic 的原理？

35.并发和并行有什么区别？

　　1、并发（concurrency）：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干片，使多个进程快速交替的执行。

　　如上图所示，并发就是只有一个CPU资源，程序（或线程）之间要竞争得到执行机会。图中的第一个阶段，在A执行的过程中，B、C不会执行，因为这段时间内这个CPU资源被A竞争到了，同理，第二阶段只有B在执行，第三阶段只有C在执行。其实，并发过程中，A、B、C并不是同时进行的（微观角度），但又是同时进行的（宏观角度）。

　　2、并行（parallellism）:指在同一时刻，有多条指令在多个处理器上同时执行 
　　

　　如图所示，在同一时刻，ABC都是同时执行（微观、宏观）

　　通过多线程实现并发，并行： 
　　? java中的Thread类定义了多线程，通过多线程可以实现并发或并行。 
　　? 在CPU比较繁忙，资源不足的时候（开启了很多进程），操作系统只为一个含有多线程的进程分配仅有的CPU资源，这些线程就会为自己尽量多抢时间片，这就是通过多线程实现并发，线程之间会竞争CPU资源争取执行机会。 
　　? 在CPU资源比较充足的时候，一个进程内的多线程，可以被分配到不同的CPU资源，这就是通过多线程实现并行。 
　　? 至于多线程实现的是并发还是并行？上面所说，所写多线程可能被分配到一个CPU内核中执行，也可能被分配到不同CPU执行，分配过程是操作系统所为，不可人为控制。所以，如果有人问我我所写的多线程是并发还是并行的？我会说，都有可能。 
　　? 不管并发还是并行，都提高了程序对CPU资源的利用率，最大限度地利用CPU资源

36.线程和进程的区别？

　　线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少需要一个线程。下面，我们从调度、并发性、 系统开销、拥有资源等方面，来比较线程与进程。

　　1．调度

　　在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位。而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程的切换，在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程的切换。

　　2．并发性

　　在引入线程的操作系统中，不仅进程之间可以并发执行，而且在一个进程中的多个线程之间，亦可并发执行，因而使操作系统具有更好的并发性，从而能更有效地使用系统资源和提高系统吞吐量。例如，在一个未引入线程的单CPU操作系统中，若仅设置一个文件服务进程，当它由于某种原因而被阻塞时，便没有其它的文件服务进程来提供服务。在引入了线程的操作系统中，可以在一个文件服务进程中，设置多个服务线程，当第一个线程等待时，文件服务进程中的第二个线程可以继续运行；当第二个线程阻塞时，第三个线程可以继续执行，从而显著地提高了文件服务的质量以及系统吞吐量。

　　3．拥有资源

　　不论是传统的操作系统，还是设有线程的操作系统，进程都是拥有资源的一个独立单位，它可以拥有自己的资源。一般地说，线程自己不拥有系统资源(也有一点必不可少的资源)，但它可以访问其隶属进程的资源。亦即，一个进程的代码段、数据段以及系统资源，如已打开的文件、I/O设备等，可供同一进程的其它所有线程共享。

　　4．系统开销

　　由于在创建或撤消进程时，系统都要为之分配或回收资源，如内存空间、I／O设备等。因此，操作系统所付出的开销将显著地大于在创建或撤消线程时的开销。类似地，在进行进程切换时，涉及到整个当前进程CPU环境的保存以及新被调度运行的进程的CPU环境的设置。而线程切换只须保存和设置少量寄存器的内容，并不涉及存储器管理方面的操作。可见，进程切换的开销也远大于线程切换的开销。此外，由于同一进程中的多个线程具有相同的地址空间，致使它们之间的同步和通信的实现，也变得比较容易。在有的系统中，线程的切换、同步和通信都无须操作系统内核的干预 。

37.守护线程是什么？

　　守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用。而其他的线程只有一种，那就是用户线程。所以java里线程分2种，

public class Thread01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i ) {
            System.out.println(i);
        }
    }
}

public class test {
    public static void main(String[] args) {
        Thread thread = new Thread01();
        thread.setDaemon(true);
        thread.start();
    }
}

38.创建线程有哪几种方式？

　　三种

　　1、继承Thread类，重写父类的run()方法

　　2、实现Runnable接口，重写run()方法，通过其实现类使用Thread

　　3、实现Callable接口，重写call()方法，通过Runnable实现类使用Thread

39.说一下 runnable 和 callable 有什么区别？

　　1、Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果

　　2、Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛

　　注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

　　Runnable接口：

public interface Runnable {
    public abstract void run();
}

　　Callable接口：

public interface Callable {
    V call() throws Exception;
}

　　Java Runnable接口和Callable接口的区别

40.线程有哪些状态？

　　虚拟机中的线程状态有六种，定义在Thread.State中：

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * 

         *   
{
@link Object#wait() Object.wait} with no timeout
         *   
{@link #join() Thread.join} with no timeout
         *   
{@link LockSupport#park() LockSupport.park}
         * 
         *
         * 
A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called Object.wait()
         * on an object is waiting for another thread to call
         * Object.notify() or Object.notifyAll() on
         * that object. A thread that has called Thread.join()
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * 

         *   
{
@link #sleep Thread.sleep}
         *   
{@link Object#wait(long) Object.wait} with timeout
         *   
{@link #join(long) Thread.join} with timeout
         *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
         *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
         * 
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
}

　　1、New：新建状态

　　当线程实例被new出来之后，调用start()方法之前，线程实例处于新建状态。比如"Thread thread = new Thread()"，thread就是一个处于NEW状态的线程。

　　2、Runnable：可运行状态

　　new出来线程，调用start()方法即处于Runnable状态了。处于Runnable状态的线程可能正在Java虚拟机中运行，也可能正在等待处理器的资源，因为一个线程必须获得CPU的资源后，才可以运行其run()方法中的内容，否则排队等待。

　　3、Blocked：阻塞状态

　　如果某一线程正在等待监视器锁，以便进入一个同步的块/方法，那么这个线程的状态就是阻塞Bloked。

　　4、Waiting：等待状态

　　某一线程因为调用不带超时的Object的wait()方法、不带超时的Thread的join()方法、LockSupport的park()方法，就会处于等待Waiting状态，等待被其它线程唤醒。

　　5、Timed_Waiting：超时等待状态

　　某一线程因为调用带有指定正等待时间（即传入时间参数）的Object的wait()方法、Thread的join()方法、Thread的sleep()方法、LockSupport的parkNanos()方法、LockSupport的parkUntil()方法，就会处于超时等待Timed_Waiting状态。

　　6、Terminated：中止状态

　　线程调用终止或者run()方法执行结束后，线程即处于终止状态。处于终止状态的线程不具备继续运行的能力。

　　线程的转换状态

　　上面也提到了，某一时间点线程的状态只能是上述6个状态中的其中一个；但是，线程在程序运行过程中的状态是会发生变化的，由一个状态转变为另一个状态，那么下面给出线程状态转换图帮助我们清晰地理解线程的状态转变过程：

　　Java多线程2：线程的使用及其生命周期

41.sleep() 和 wait() 有什么区别？

　　1、这两个方法来自不同的类，sleep来自Thread类，而wait来自Object类。

　　2、sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

　　3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 

42.notify()和 notifyAll()有什么区别？

　　假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。

　　如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。

　　如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

　　java中的锁池和等待池

43.线程的 run()和 start()有什么区别？

　　线程通过调用start方法启动，然后执行run()方法中的内容，使用start方法才真正实现了多线程运行，因为这个时候不用等待我们的run方法执行完成就可以继续执行下面的代码，这才叫多线程嘛！

　　直接使用thread执行run方法呢？因为run方法是thread里面的一个普通的方法，所以我们直接调用run方法，这个时候它是会运行在我们的主线程中的，因为这个时候我们的程序中只有主线程一个线程，那么他们的执行顺序一定是顺序执行，所以这样并没有做到多线程的这种目的。

44.创建线程池有哪几种方式？

　　1、newSingleThreadExecutor()

　　创建一个单线程化的Executor，即只创建唯一的工作线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

　　2、newFixedThreadPool(int nThreads)

　　创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

　　3、newCachedThreadPool()

　　创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

　　这种类型的线程池特点是：

• 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
• 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
• 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

　　4、newScheduledThreadPool(int corePoolSize)

　　创建一个定长的线程池，而且支持定时的以及周期性的任务执行

　　为什么要使用线程池；常见的创建线程池的4种方式

45.线程池都有哪些状态？

　　线程池的五种状态：

　　1、RUNNING

　　(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。 
　　(02) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

　　2、 SHUTDOWN

　　(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。 
　　(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

　　3、STOP

　　(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。 
　　(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

　　4、TIDYING

　　(1) 状态说明：当所有的任务已终止，ctl记录的”workerCount”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。 
　　(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。 
　　当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

　　5、 TERMINATED

　　(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。 
　　(2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

　　Java多线程11：线程池

46.线程池中 submit()和 execute()方法有什么区别？

　　先看一下ExecutorService接口定义的三种submit方法

　　1、Future submit(Callable task)

public class test {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        List> list = new ArrayList();
        for (int i = 0; i ) {
            Future submit = executorService.submit(new Callable() {
                @Override
                public String call() throws Exception {
                    return "call方法返回字符串";
                }
            });
            list.add(submit);
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("返回结果list的size====" + list.size());
        for (Future stringFuture : list) {
            try {
                String s = stringFuture.get();
                System.out.println("返回结果====" + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        executorService.shutdown();
    }
}

　　结果：

返回结果list的size====5
返回结果====call方法返回字符串
返回结果====call方法返回字符串
返回结果====call方法返回字符串
返回结果====call方法返回字符串
返回结果====call方法返回字符串

　　可以看到，Callable接口定义的call()方法是有返回值的，所以可以通过submit(Callable task)的结果submit.get()获取返回值。

　　2、Future> submit(Runnable task);

public class test {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        List> list = new ArrayList();
        for (int i = 0; i ) {
            final int num = i;
            Future> submit = executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(num);
                }
            });
            list.add(submit);
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("返回结果list的size====" + list.size());
        for (Future> future : list) {
            boolean done = future.isDone();
            System.out.println("执行是否成功===" + done);
        }
        executorService.shutdown();
    }
}

　　结果：

1
2
0
4
3
返回结果list的size====5
执行是否成功===true
执行是否成功===true
执行是否成功===true
执行是否成功===true
执行是否成功===true

　　可以看到，Runnable接口定义的run()方法是没有返回值的，但是可以通过submit(Callable task)的结果submit.isDone()判断是否执行成功。

　　3、Future submit(Runnable task, T result)

public class test {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        List> list = new ArrayList();
        for (int i = 0; i ) {
            final int num = i;
            String s = "runnable的返回值";
            Future submit = executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(num);
                }
            }, s);
            list.add(submit);
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("返回结果list的size====" + list.size());
        for (Future future : list) {
            String s = null;
            try {
                s = future.get();
                System.out.println(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        executorService.shutdown();
    }
}

　　结果：

0
2
4
3
1
返回结果list的size====5
runnable的返回值
runnable的返回值
runnable的返回值
runnable的返回值
runnable的返回值

　　可以看到，Runnable接口定义的run()方法是没有返回值的，但是submit()方法的第二个参数可以定义返回值。

　　关于以上三种submit是怎么执行的，参考：理解三种任务Runnable和Callable和FutureTask的用法

　　所以，submit()和 execute()方法有什么区别？

　　1、submit()方法是否返回值的，executor()方法是没有返回值的。

　　2、submit在执行过程中与execute不一样，不会抛出异常而是把异常保存在成员变量中，在FutureTask.get获取的时候再把异常抛出来。

　　3、execute直接抛出异常之后线程就死掉了，submit保存异常线程没有死掉，因此execute的线程池可能会出现没有意义的情况，因为线程没有得到重用。而submit不会出现这种情况。

　　后两个区别参考：并发编程之submit和execute区别（七）

47.在 java 程序中怎么保证多线程的运行安全？

48.多线程锁的升级原理是什么？

49.什么是死锁？

50.怎么防止死锁？

51.ThreadLocal 是什么？有哪些使用场景？

52.说一下 synchronized 底层实现原理？

53.synchronized 和 volatile 的区别是什么？

54.synchronized 和 Lock 有什么区别？

55.synchronized 和 ReentrantLock 区别是什么？

56.说一下 atomic 的原理？

面试知识点三：Java多线程

标签：shutdown   字符串   tran   alt   中断   异常抛出   calling   new   fixed   

原文地址：https://www.cnblogs.com/zfyang2429/p/11060457.html