1、开启线程的三种方式

• 继承Thread类，重写run()方法，在run()方法体中编写要完成的任务

new Thread().start();

• 实现Runnable接口，实现run()方法

new Thread(new CusRunnable()).start();

• 实现Callable接口MyCallable类，实现call()方法，使用FutureTask类来包装Callable对象，使用FutureTask对象作为Thread对象的target创建并启动线程；调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

FutureTask<Integer> ft = 
new FutureTask<Integer>(new MyCallable());

new Thread(ft).start();

2、run()和start()方法区别

run()方法只是线程的主体方法，和普通方法一样，不会创建新的线程。只有调用start()方法，才会启动一个新的线程，新线程才会调用run()方法，线程才会开始执行。

3、如何控制某个方法允许并发访问线程的个数？

创建Semaphore变量

Semaphore semaphore = new Semaphore(5, true);

当方法进入时，请求一个信号，如果信号被用完则等待，方法运行完，释放一个信号，释放的信号新的线程就可以使用。

4、在Java中wait和sleep方法发不同

wait()方法属于Object类，调用该方法时，线程会放弃对象锁，只有改对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

5、谈谈wait/notify关键字的理解

notify:唤醒在此对象监视器上等待的单个线程
notifyAll():通知所有等待该竞争资源的线程
wait：释放obj的锁，导致当前的线程等待，直到其它线程调用此对象的notify()或者notifyAll()方法。

当药调用wait()或者notify()/notifyAll()方法时，一定要对竞争资源进行加锁，一般放到synchronized(obj)代码中。当调用obj.notify/notifyAll后。调用线程依旧持有obj锁，因此等待线程虽被唤醒，但仍无法获得obj锁，直到调用线程退出synchronized块，释放obj锁后，其他等待线程才有机会获得锁继续执行。

6、什么导致线程阻塞？

• 一般线程阻塞
  1、线程执行了Thread.sleep()方法，放弃CPU，睡眠一段时间，一段时间过后恢复执行；
  2、线程执行一段同步代码，但无法获得相关的同步锁，只能进入阻塞状态，等到获得同步锁，才能恢复执行；
  3、线程执行了一个对象的wait()方法，直接进入阻塞态，等待其他线程执行notify()/notifyAll()操作；
  4、线程执行某些IO操作，因为等待相关资源而进入了阻塞态，如System.in，但没有收到键盘的输入，则进入阻塞态。
  5、线程礼让，Thread.yield()方法，暂停当前正在执行的线程对象，把执行机会让给相同或更高优先级的线程，但并不会使线程进入阻塞态，线程仍处于可执行态，随时可能再次分得CPU时间。线程自闭，join()方法，在当前线程调用另一个线程的join()方法，则当前线程进入阻塞态，直到另一个线程运行结束，当前线程再由阻塞转为就绪态。
  6、线程执行suspend()使线程进入阻塞态，必须resume()方法被调用，才能使线程重新进入可执行状态。

7、线程如何关闭？

• 使用标志位
• 使用stop()方法，但该方法就像强制关掉电脑电源一样，可能会发生预料不到的问题，interest
  -使用中断interrupt()

public class Thread {
    // 中断当前线程
    public void interrupt();
    // 判断当前线程是否被中断
    public boolen isInterrupt();
    // 清除当前线程的中断状态，并返回之前的值
    public static boolen interrupted();   
}

当调用interrupt()方法只是传递中断请求消息，并不代表要立马停止目标线程。

8、讲一下java中的同步的方法

在多线程并发控制，当多个线程同时操作一个可共享的资源时，如果没有才去同步机制，将会导致数据不准确，因此需要加入同步锁，确保在该线程没有完成操作前被其他线程调用，从而保证该变量的唯一性和准确性。

• synchronized修饰同步代码块或方法
  由于java的每个对象都有一个内置锁，用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需获得内置锁，否则就处于阴塞状态。
• volatile修饰变量
  保证变量在线程间的可见性，每次线程要访问volatile修饰的变量时都从内存中读取，而不缓存中，这样每个线程访问到的变量都是一样的。且使用内存屏障。
• ReentrantLock重入锁
  常用的方法有ReentrantLock()：创建一个ReentrantLock实例

lock()获得锁 unlock()释放锁

• 使用局部变量ThreadLocal实现线程同步
  每个线程都会保存一份该变量的副本，副本之间相互独立，这样每个线程都可以随意修改自己的副本，而不影响其他线程。常用方法ThreadLocal()创建一个线程本地变量；get()返回此线程局部的当前线程副本变量；initialValue()返回此线程局部变量的当前线程的初始值；set(T value)将此线程变量的当前线程副本中的值设置为value
• 使用原子变量，如AtomicInteger
  AtomicInteger(int value)创建个有给定初始值的AtomicInteger整数；addAndGet(int data)以原子方式将给定值与当前值相加
  -使用阻塞队列实现线程同步LinkedBlockingQueue<E>

9、如何保证线程安全？

线程安全性体现在三方法：

• 原子性：提供互斥访问，同一时刻只能有一个线和至数据进行操作。
  JDK中提供了很多atomic类，如AtomicInteger\AtomicBoolean\AtomicLong，它们是通过CAS完成原子性。JDK提供锁分为两种：synchronized依赖JVM实现锁，该关键字作用对象的作用范围内同一时刻只能有一个线程进行操作。另一种是LOCK,是JDK提供的代码层面的锁，依赖CPU指令，代表性是ReentrantLock。
• 可见性：一个线程对主内存的修改及时被其他线程看到。
  JVM提供了synchronized和volatile，volatile的可见性是通过内存屏障和禁止重排序实现的，volatile会在写操作时，在写操作后加一条store屏障指令，将本地内存中的共享变量值刷新到主内存；会在读操作时，在读操作前加一条load指令，从内存中读取共享变量。
• 有序性：指令没有被编译器重排序。
  可通过volatile、synchronized、Lock保证有序性。

10、两个进程同时要求写或者读，能不能实现？如何防止进程的同步？

两个进程都读取日历进程数据是没有问题，但同时写，应该会有冲突。
可以使用共享内存实现进程间数据共享。ps:共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。

11、线程间操作List

for(int i=M,i<COUNT/N;i+=N)
{
}
按照这个思路，然后在线程中加一个变量来处理，
那么每个线程就是100 / 3取整后的条数，最后多出的100 - 3 * 33的那一条就加在第3个线程里处理好了
可以让每个线程处理自己的，不用都交给最后一个线程

12、Java中对象的生命周期

• 创建阶段（Created）：
  为对象分配存储空间，开始构造对象，从超类到子类对static成员初始化；超类成员变量按顺序初始化，递归调用超类的构造方法，子类成员变量按顺序初始化，子类构造方法调用。
• 应用阶段（In Use）：
  对象至少被一个强引用持有着。
• 不可见阶段（Invisible）：
  程序运行已超出对象作用域
• 不可达阶段（Unreachable）：
  该对象不再被强引用所持有
• 收集阶段（Collected）：
  假设该对象重写了finalize()方法且未执行过，会去执行该方法。
• 终结阶段（Finalized）：
  对象运行完finalize()方法仍处于不可达状态，等待垃圾回收器对该对象空间进行回收。
• 对象空间重新分配阶段（De-allocated）：
  垃圾回收器对该对象所占用的内存空间进行回收或再分配，该对象彻底消失。

13、static synchronized 方法的多线程访问和作用

static synchronized控制的是类的所有实例访问，不管new了多少对象，只有一份，所以对该类的所有对象都加了锁。限制多线程中该类的所有实例同时访问JVM中该类对应的代码。

14、同一个类里面两个synchronized方法，两个线程同时访问的问题

如果synchronized修饰的是静态方法，锁的是当前类的class对象，进入同步代码前要获得当前类对象的锁；
普通方法，锁的是当前实例对象，进入同步代码前要获得的是当前实例的锁；
同步代码块，锁的是括号里面的对象，对给定的对象加锁，进入同步代码块库前要获得给定对象锁；
如果两个线程访问同一个对象的synchronized方法，会出现竞争，如果是不同对象，则不会相互影响。

15、volatile的原理

有volatile变量修饰的共享变量进行写操作的时候会多一条汇编代码，lock addl $0x0，lock前缀的指令在多核处理器下会将当前处理器缓存行的数据会写回到系统内存，这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效。同时lock前缀也相当于一个内存屏障，对内存操作顺序进行了限制。

16、synchronized原理

synchronized通过对象的对象头（markword)来实现锁机制，java每个对象都有对象头，都可以为synchronized实现提供基础，都可以作为锁对象，在字节码层面synchronized块是通过插入monitorenter monitorexit完成同步的。持有monitor对象，通过进入、退出这个Monitor对象来实现锁机制。

17、谈谈NIO的理解

NIO( New Input/ Output) 引入了一种基于通道和缓冲区的 I/O 方式，它可以使用 Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆的 DirectByteBuffer 对象作为这块内存的引用进行操作，避免了在 Java 堆和 Native 堆中来回复制数据。 NIO 是一种同步非阻塞的 IO 模型。同步是指线程不断轮询 IO 事件是否就绪，非阻塞是指线程在等待 IO 的时候，可以同时做其他任务。同步的核心就是 Selector，Selector 代替了线程本身轮询 IO 事件，避免了阻塞同时减少了不必要的线程消耗；非阻塞的核心就是通道和缓冲区，当 IO 事件就绪时，可以通过写道缓冲区，保证 IO 的成功，而无需线程阻塞式地等待。

-synchronized 和volatile 关键字的区别
-synchronized与Lock的区别
-ReentrantLock 、synchronized和volatile比较

1）volatile：解决变量在多个线程间的可见性，但不能保证原子性，只能用于修饰变量，不会发生阻塞。volatile能屏蔽编译指令重排，不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面。多用于并行计算的单例模式。volatile规定CPU每次都必须从内存读取数据，不能从CPU缓存中读取，保证了多线程在多CPU计算中永远拿到的都是最新的值。

2）synchronized：互斥锁，操作互斥，并发线程过来，串行获得锁，串行执行代码。解决的是多个线程间访问共享资源的同步性，可保证原子性，也可间接保证可见性，因为它会将私有内存和公有内存中的数据做同步。可用来修饰方法、代码块。会出现阻塞。synchronized发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生。非公平锁，每次都是相互争抢资源。

3）lock是一个接口，而synchronized是java中的关键字，synchronized是内置语言的实现。lock可以让等待锁的线程响应中断。在发生异常时，如果没有主动通过unLock()去释放锁，则可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。

4）ReentrantLock可重入锁，锁的分配机制是基于线程的分配，而不是基于方法调用的分配。ReentrantLock有tryLock方法，如果锁被其他线程持有，返回false，可避免形成死锁。对代码加锁的颗粒会更小，更节省资源，提高代码性能。ReentrantLock可实现公平锁和非公平锁，公平锁就是先来的先获取资源。ReentrantReadWriteLock用于读多写少的场合，且读不需要互斥场景。

-ReentrantLock的内部实现
-lock原理
-死锁的四个必要条件？
死锁是指多个进程因竞争资源而造成的一种僵局（互相等待）
互斥条件：一个资源每次只能被一个进程使用，即在一段时间内某 资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

请求与保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源 已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

不可剥夺条件:进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能 由获得该资源的进程自己来释放（只能是主动释放)。

循环等待条件: 若干进程间形成首尾相接循环等待资源的关系

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。
-怎么避免死锁？

避免：
死锁避免的基本思想：系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源，如果分配后系统可能发生死锁，则不予分配，否则予以分配，这是一种保证系统不进入死锁状态的动态策略。
预防：
破坏死锁产生的4个必要条件来 预防死锁，由于资源互斥是资源使用的固有特性是无法改变的。
破坏“不可剥夺”条件：一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到 系统的资源列表中，可以被其他的进程使用，而等待的进程只有重新获得自己原有的资源以及新申请的资源才可以重新启动，执行。
破坏”请求与保持条件“：第一种方法静态分配即每个进程在开始执行时就申请他所需要的全部资源。第二种是动态分配即每个进程在申请所需要的资源时他本身不占用系统资源。
破坏“循环等待”条件：采用资源有序分配其基本思想是将系统中的所有资源顺序编号，将紧缺的，稀少的采用较大的编号，在申请资源时必须按照编号的顺序进行，一个进程只有获得较小编号的进程才能申请较大编号的进程。

-对象锁和类锁是否会互相影响？
-什么是线程池，如何使用?
-Java的并发、多线程、线程模型
-谈谈对多线程的理解
-多线程有什么要注意的问题？
-谈谈你对并发编程的理解并举例说明
-谈谈你对多线程同步机制的理解？
-如何保证多线程读写文件的安全？
-多线程断点续传原理
-断点续传的实现
（五）并发编程有关知识点（这个是一般Android开发用的少的，所以建议多去看看）：

平时Android开发中对并发编程可以做得比较少，Thread这个类经常会用到，但是我们想提升自己的话，一定不能停留在表面，,我们也应该去了解一下java的关于线程相关的源码级别的东西。