35. 并行（parallellism ）和并发（concurrency）有什么区别？

• 并行：同一时刻有多条指令在多个处理器上同时执行，无论从宏观还是微观上都是同时发生的。
• 并发：是指在同一时间段内，宏观上看多个指令看起来是同时执行，微观上看是多个指令进程在快速的切换执行，同一时刻只有一条指令被执行。

要点：
1）关键是看同一时刻是否同时在执行
2）并行在多处理器中存在，并发可以存在但处理器或多处理器
3）当有多个线程在操作时，如果是单核 CPU，则它根本不可能真正同时进行一个以上的线程，它只能把 CPU 运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时,其它线程处于挂起状态.这种方式我们称之为并发（Concurrent）。
4）当系统有一个以上 CPU 或者多核CPU时，则线程的操作有可能非并发。当一个 CPU 执行一个线程时，另一个 CPU 可以执行另一个线程，两个线程互不抢占 CPU 资源，可以同时进行，这种方式我们称之为并行（Parallel）。

36. 线程和进程的区别？

• 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
• 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
• 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信号等)，某进程内的线程在其他进程不可见；
• 调度和切换：线程上下文切换比进程上下文切换要快得多。

37. 守护（Deamond）线程是什么？

• 守护线程拥有自动结束自己生命周期的特性，而非守护线程不具备这个特点
• JVM 中的垃圾回收线程就是典型的守护线程，如果说不具备该特性，会发生什么呢？
  当 JVM 要退出时，由于垃圾回收线程还在运行着，导致程序无法退出，这就很尴尬了！！！由此可见，守护线程的重要性了。
• 通常来说，守护线程经常被用来执行一些后台任务，但是呢，你又希望在程序退出时，或者说 JVM 退出时，线程能够自动关闭，此时，守护线程是你的首选。
  什么是守护线程

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

1. 继承Thread类创建线程类
   1)定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了2)线程要完成的任务。因此把run()方法称为执行体。
   3)创建Thread子类的实例，即创建了线程对象。
   4)调用线程对象的start()方法来启动该线程。

public class FirstThreadTest extends Thread {
    int i = 0;
    //重写run方法，run方法的方法体就是现场执行体
    public void run() {
        for (; i < 100; i++) {
            System.out.println(getName() + "  " + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "  : " + i);
            if (i == 50) {
                new FirstThreadTest().start();
                new FirstThreadTest().start();
            }
        }
    }
}

2. 通过Runnable接口创建线程类
   1)定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
   2)创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
   3)调用线程对象的start()方法来启动该线程。

public class RunnableThreadTest implements Runnable{
        private int i;
        public void run()
        {
            for(i = 0;i <100;i++)
            {
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
        public static void main(String[] args)
        {
            for(int i = 0;i < 100;i++)
            {
                System.out.println(Thread.currentThread().getName()+" "+i);
                if(i==20)
                {
                    RunnableThreadTest rtt = new RunnableThreadTest();
                    new Thread(rtt,"新线程1").start();
                    new Thread(rtt,"新线程2").start();
                }
            }
        }
}

3. 通过Callable和Future创建线程
   1)创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
   2)创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
   3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
   4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableThreadTest implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }

    public static void main(String[] args) throws Exception {
        //创建实例
        CallableThreadTest ctt = new CallableThreadTest();
        //用FutureTask包装
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 20) {
                //子线程执行
                new Thread(ft, "有返回值的线程").start();
            }
        }
        //获取到子线程执行的返回值
        System.out.println("子线程的返回值：" + ft.get())；
    }
}

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

• Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；
• Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

40. 线程有哪些状态？

线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

• 创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
• 就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
• 运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
• 阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep，suspend，wait等方法都可以导致线程阻塞。
• 死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪

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

• sleep()：方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。
• wait()：wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程。

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

这两个方法都是Object类下面的方法

• 如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
• 当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程)，被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只有一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。
• 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

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

• 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
• start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
• run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接调用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
• 调用start()方法是启动新线程执行，调用run()方法其实就是调用类的普通方法，没有开启新线程执行，还是在本线程里执行逻辑

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

1. newFixedThreadPool(int nThreads)
   创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。

ExecutorService es=Executors.newFixedThreadPool(2);

2. newCachedThreadPool()
   创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。

ExecutorService es=Executors.newCachedThreadPool();

3. newSingleThreadExecutor()
   这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。

ExecutorService es=Executors.newSingleThreadExecutor();

4. newScheduledThreadPool(int corePoolSize)
   创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

ScheduledExecutorService es=Executors.newScheduledThreadPool(2);

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

线程池有5种状态：Running、ShutDown、Stop、Tidying、Terminated。
线程池的5个状态

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

• submit是有返回值的，execute没有返回值
• submit可以接收实现Runnable接口的类，实现Callable的类；Execut只能接收实现Runnable接口的类

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

线程安全在三个方面体现：

• 原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
• 可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
• 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）

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

• 在Java中，锁共有4种状态，级别从低到高依次为：无状态锁，偏向锁，轻量级锁和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级。
  聊聊并发（二）Java SE1.6中的Synchronized
  Java中的每一个对象都可以作为锁。
  1.对于同步方法，锁是当前实例对象。
  2.对于静态同步方法，锁是当前对象的Class对象。
  3.对于同步方法块，锁是Synchonized括号里配置的对象。
  “锁”存在Java对象头里，使用不同的标记值表示“锁”当前所处的状态。
• Java SE1.6为了减少获得锁和释放锁所带来的性能消耗，引入了“偏向锁”和“轻量级锁”，所以在Java SE1.6里锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态，它会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率
  具体可以参考上文
  下面这篇文章全面讲java里面的各种锁，非常不错：java中的各种锁

49 . 什么是死锁？

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。
什么是死锁，死锁的原因及解决办法

50. 怎么防止死锁？

死锁的四个必要条件：

• 互斥条件：进程对所分配到的资源不允许其他进程进行访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源

• 请求和保持条件：进程获得一定的资源之后，又对其他资源发出请求，但是该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放

• 不可剥夺条件：是指进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用完后自己释放

• 环路等待条件：是指进程发生死锁后，若干进程之间形成一种头尾相接的循环等待资源关系

  所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确 定资源的合理分配算法，避免进程永久占据系统资源。
  此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。

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

• def:线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。
• Java提供ThreadLocal类来支持线程局部变量，是一种实现线程安全的方式。
• 任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。
  ThreadLocal

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

synchronized

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

• volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
• volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。
• volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。
• volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
• volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。

54. synchronized 和 Lock 有什么区别？

• 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
• synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
• synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
• 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
• synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
• Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

55. synchronized 和 ReentrantLock 区别是什么？

• synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量

• ReentrantLock比synchronized的扩展性体现在几点上：
  1.ReentrantLock可以对获取锁的等待时间进行设置，这样就避免了死锁
  2.ReentrantLock可以获取各种锁的信息
  3.ReentrantLock可以灵活地实现多路通知
  4.另外，二者的锁机制其实也是不一样的

56. 说一下 atomic 的原理？
    Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。