Android面试题总结（四）线程，多线程，线程池

1.开启线程的三中方式？

https://blog.csdn.net/longshengguoji/article/details/41126119（转）

https://blog.csdn.net/u012973218/article/details/51280044（转）

2.线程和进程的区别？

https://blog.csdn.net/mxsgoden/article/details/8821936（转）

3.run()和start()方法区别？

1.start（）方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：

通过调用Thread类的start()方法来启动一个线程，
这时此线程是处于就绪状态，
并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，
这里方法run()称为线程体，
它包含了要执行的这个线程的内容，
Run方法运行结束，
此线程终止，
而CPU再运行其它线程，

 

2.run（）方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码：

而如果直接用Run方法，
这只是调用一个方法而已，
程序中依然只有主线程--这一个线程，
其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

 

举例说明一下：

记住：线程就是为了更好地利用CPU，
提高程序运行速率的！

public class TestThread1{
public static void main(String[] args){
Runner1 r=new Runner1();
//r.run();//这是方法调用，而不是开启一个线程
Thread t=new Thread(r);//调用了Thread(Runnable target)方法。且父类对象变量指向子类对象。
t.start();

for(int i=0;i<100;i++){
System.out.println("进入Main Thread运行状态");
System.out.println(i);
}
}
}
class Runner1 implements Runnable{ //实现了这个接口，jdk就知道这个类是一个线程
public void run(){

for(int i=0;i<100;i++){
System.out.println("进入Runner1运行状态");
System.out.println(i);
}
}

}

4.java线程中wait和sleep的不同？

https://www.cnblogs.com/DreamSea/archive/2012/01/16/2263844.html（转）

5.谈谈对wait和notify关键字的理解？

1. 使用wait()、notify()和notifyAll()时需要首先对调用对象加锁
2. 调用wait()方法后，线程状态会从RUNNING变为WAITING，并将当线程加入到lock对象的等待队列中
3. 调用notify()或者notifyAll()方法后，等待在lock对象的等待队列的线程不会马上从wait()方法返回，必须要等到调用notify()或者notifyAll()方法的线程将lock锁释放，等待线程才有机会从等待队列返回。这里只是有机会，因为锁释放后，等待线程会出现竞争，只有竞争到该锁的线程才会从wait()方法返回，其他的线程只能继续等待
4. notify()方法将等待队列中的一个线程移到lock对象的同步队列，notifyAll()方法则是将等待队列中所有线程移到lock对象的同步队列，被移动的线程的状态由WAITING变为BLOCKED
5. wait()方法上等待锁，可以通过wait(long timeout)设置等待的超时时间

https://blog.csdn.net/u011116672/article/details/51044958（转自）

6.什么导致线程阻塞？

 线程在运行的过程中因为某些原因而发生阻塞，阻塞状态的线程的特点是：该线程放弃CPU的使用，暂停运行，只有等到导致阻塞的原因消除之后才回复运行。或者是被其他的线程中断，该线程也会退出阻塞状态，同时抛出InterruptedException。

        导致阻塞的原因有很多种，大致分为三种来讨论，分别是一般线程中的阻塞，Socket客户端的阻塞，Socket服务器端的阻塞。

一般线程中的阻塞：

        A、线程执行了Thread.sleep(int millsecond);方法，当前线程放弃CPU，睡眠一段时间，然后再恢复执行

        B、线程执行一段同步代码，但是尚且无法获得相关的同步锁，只能进入阻塞状态，等到获取了同步锁，才能回复执行。

        C、线程执行了一个对象的wait()方法，直接进入阻塞状态，等待其他线程执行notify()或者notifyAll()方法。

        D、线程执行某些IO操作，因为等待相关的资源而进入了阻塞状态。比如说监听system.in，但是尚且没有收到键盘的输入，则进入阻塞状态。

Socket客户端的阻塞：

        A、请求与服务器连接时，调用connect方法，进入阻塞状态，直至连接成功。

        B、当从Socket输入流读取数据时，在读取足够的数据之前会进入阻塞状态。比如说通过BufferedReader类使用readLine()方法时，在没有读出一行数据之前，数据量就不算是足够，会处在阻塞状态下。

        C、调用Socket的setSoLinger()方法关闭了Socket延迟，当执行Socket的close方法时，会进入阻塞状态，知道底层Socket发送完所有的剩余数据

Socket服务器的阻塞：

        A、线程执行ServerSocket的accept()方法，等待客户的连接，知道接收到客户的连接，才从accept方法中返回一个Socket对象

        B、从Socket输入流读取数据时，如果输入流没有足够的数据，就会进入阻塞状态

        D、线程向Socket的输出流写入一批数据，可能进入阻塞状态

        当程序阻塞时，会降低程序的效率，于是人们就希望能引入非阻塞的操作方法。    

        所谓非阻塞方法，就是指当线程执行这些方法时，如果操作还没有就绪，就立即返回，不会阻塞着等待操作就绪。Java.nio 提供了这些支持非阻塞通信的类。

7. 线程如何关闭？

https://blog.csdn.net/feiduclear_up/article/details/43270375（转）

https://blog.csdn.net/wuyupengwoaini/article/details/49537131（转）

8.java线程中同步的方法？

https://www.cnblogs.com/XHJT/p/3897440.html（转）

9.如何保证线程安全？

https://blog.csdn.net/xiangxianghehe/article/details/51135299（转）

10.谈谈对Synchronized关键字，类锁，方法锁，重入锁的理解？

https://blog.csdn.net/yuxin6866/article/details/79884723（转）

11.volatile的原理及使用

http://www.importnew.com/23520.html（转）

http://www.cnblogs.com/paddix/p/5428507.html（转）

https://monkeysayhi.github.io/2016/11/29/volatile%E5%85%B3%E9%94%AE%E5%AD%97%E7%9A%84%E4%BD%9C%E7%94%A8%E3%80%81%E5%8E%9F%E7%90%86/（转）

12.谈谈对NIO的理解

BIO，同步阻塞式IO，一个连接一个线程，这个线程只针对这个连接而存在，专注于它的收发，如果没有数据读入它就一直阻塞等待。当然可以通过线程池改善。

AIO，同步非阻塞式IO，一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。用户进程也需要时不时的询问IO操作是否就绪，这就要求用户进程不停的去询问。 

NIO，异步非阻塞式IO，一个有效请求一个线程，用户进程只需要发起一个IO操作然后立即返回，等IO操作真正的完成以后，应用程序会得到IO操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的IO读写操作。

13.synchronized 和volatile 关键字的区别

首先需要理解线程安全的两个方面：执行控制和内存可见。

执行控制的目的是控制代码执行（顺序）及是否可以并发执行。

内存可见控制的是线程执行结果在内存中对其它线程的可见性。根据Java内存模型的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。

synchronized关键字解决的是执行控制的问题，它会阻止其它线程获取当前对象的监控锁，这样就使得当前对象中被synchronized关键字保护的代码块无法被其它线程访问，也就无法并发执行。更重要的是，synchronized还会创建一个内存屏障，内存屏障指令保证了所有CPU操作结果都会直接刷到主存中，从而保证了操作的内存可见性，同时也使得先获得这个锁的线程的所有操作，都happens-before于随后获得这个锁的线程的操作。

volatile关键字解决的是内存可见性的问题，会使得所有对volatile变量的读写都会直接刷到主存，即保证了变量的可见性。这样就能满足一些对变量可见性有要求而对读取顺序没有要求的需求。

使用volatile关键字仅能实现对原始变量(如boolen、 short 、int 、long等)操作的原子性，但需要特别注意， volatile不能保证复合操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。

在Java 5提供了原子数据类型atomic wrapper classes，对它们的increase之类的操作都是原子操作，不需要使用sychronized关键字。

对于volatile关键字，当且仅当满足以下所有条件时可使用：

1. 对变量的写入操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。
2. 该变量没有包含在具有其他变量的不变式中。

• 1
• 2
• 3

volatile和synchronized的区别

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

14.死锁的必要条件和避免方式

https://blog.csdn.net/abigale1011/article/details/6450845（转）

15.对象锁和类锁是否会互相影响？

 对象锁：Java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的1个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。

·        类锁：对象锁是用来控制实例方法之间的同步，类锁是用来控制静态方法（或静态变量互斥体）之间的同步。其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。我们都知道，java类可能会有很多个对象，但是只有1个Class对象，也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象，只不过有点特殊而已。由于每个java对象都有1个互斥锁，而类的静态方法是需要Class对象。所以所谓的类锁，不过是Class对象的锁而已。获取类的Class对象有好几种，最简单的就是MyClass.class的方式。

·        类锁和对象锁不是同1个东西，一个是类的Class对象的锁，一个是类的实例的锁。也就是说：1个线程访问静态synchronized的时候，允许另一个线程访问对象的实例synchronized方法。反过来也是成立的，因为他们需要的锁是不同的。

类锁,对象锁，私有锁

1. 类锁：在代码中的方法上加了static和synchronized的锁，或者synchronized(xxx.class）的代码段

2.对象锁：在代码中的方法上加了synchronized的锁，或者synchronized(this）的代码段

3.私有锁：在类内部声明一个私有属性如private Object lock，在需要加锁的代码段synchronized(lock）

对象锁：假设我有一个类ClassA，其中有一个方法synchronized methodA()，那么当这个方法被调用的时候你获得就是对象锁。

举例：ClassA a = new ClassA(); ClassA b = new ClassA(); 那么如果你在a这对象上调用了methodA，不会影响b这个对象，也就是说对于b这个对象，他也可以调用methodA，因为这是两对象，所以说对象锁是针对对象的

类锁，其实没有所谓的类锁，因为类锁实际上就是这个类的对象的对象锁

举例:我有一个类ClassA，其中有一个方法synchronized static methodA()，注意这个方法是静态的了，那就是说这个类的所有的对象都公用一个这个方法了，那如果你在这个类的某个对象上调用了这个方法，那么其他的对象如果想要用这个方法就得等着锁被释放，所以感觉就好像这个类被锁住了一样。

16，线程，多线程，线程池的总结

https://www.jianshu.com/p/b8197dd2934c（转）

17.多线程断点续传原理

在下载大文件的时候，我们往往要使用多线程断点续传，保证数据的完整性，首先说多线程，我们要多线程下载一个大文件，就有开启多个线程，多个connection，既然是一个文件分开几个线程来下载，那肯定就是一个线程下载一个部分，如果文件的大小是200M, 使用两个线程下载， 第一个线程下载1-100M, 第二个线程下载101-200M。 
我们在请求的header里面设置

conn.setRequestProperty("Range", "bytes="+startPos+"-"+endPos);  

• 1

这里startPos是指从数据端的哪里开始，endPos是指数据端的结束 
根据这样我们就知道，只要多个线程，按顺序指定好开始跟结束，就可以解决下载冲突的问题了。

如何写文件

byte[] buffer = new byte[1024];  
int offset = 0;   
RandomAccessFile threadFile = new RandomAccessFile(this.saveFile,"rwd");  
threadFile.seek(startPos);  
threadFile.write(buffer,0,offset);  

• 1
• 2
• 3
• 4
• 5

从上面代码可以看出，每个线程找到自己开始写的位置，就是seek(startPos) 
这样就可以保证数据的完整性，也不会重复写入了

基本上多线程的原理就是这样，其实也很简单 
那么我们接着说断点续传，断点续传其实也很简单，原理就是使用数据库保存上次每个线程下载的位置和长度 
例如我开了两个线程T1，T2来下载一个文件，设文件总大小为1024M，那么就是每个线程下载512M 
可是我的下载中断了，那么我下次启动线程的时候（继续下载），是不是应该要知道，我原来下载了多少呢 
所以是这样的，每下载一点，就更新数据库的数据，