一、线程和进程的区别
（进程是资源分配的最小单位，线程是CPU调度的最小单位）
在Java程序中，Java会对操作系统提供的功能进行封装，其中就有线程和进程，当我们运行一个程序的时候，就会产生一个进程，而一个进程至少包含一个线程。并且每个进程对应一个JVM实例，多个线程共享JVM的堆。Java中采用单线程编程模型，程序会自动创建主线程，并且主线程可以创建子线程，原则上要后于子线程完成执行。
二、Thread中Start()和Run()方法的区别
- Start()方法会调用JVM的StartThread方法创建一个新的子线程，并通过JVM的Thread_run来调用run方法
- run()方法只是Thread的一个普通方法，直接可以调用。
三、Thread和Runnable是什么关系
- Thread只是一个类，并且实现了Runnable的接口
四、如何实现处理线程的返回值
1、主线程等待法
public class CycleWait implements Runnable{
private String value;
public void run(){
try{
Thread.currentThread().sleep(5000);
}catch(Exception e){
e.printStackTrace();
}
value="we have data now";
}
public static void main(String[] args){
CycleWait c= new CycleWait();
Thread t1=new Thread(c);
t1.start();
while(c.value=null){//此处使用while循环来等待线程的结束
Thread.sleep(100);
}
System.out.println("value : "+value);
}
}优点：简单
缺点：需要自己书写等待循环的逻辑，并且循环多久也不确定
2、使用Thread类的join（）阻塞当前线程以等待子线程处理完毕
public class CycleWait implements Runnable{
private String value;
public void run(){
try{
Thread.currentThread().sleep(5000);
}catch(Exception e){
e.printStackTrace();
}
value="we have data now";
}
public static void main(String[] args){
CycleWait c= new CycleWait();
Thread t1=new Thread(c);
t1.start();
t1.join();//使用join阻塞，来等待线程处理完毕
System.out.println("value : "+value);
}
}缺点：粒度不够细。如果join()之前有多个线程start()，则会统统阻塞。
补充：join的源码
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {//如果join()没有传值
while (isAlive()) {//isAlive()判断当前线程是否存活，如果存活就继续阻塞
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}join具体实现就是通过wait()来完成的。
3、通过Callable接口：通过FutureTask Or 线程池获取
public class MyCallable implements Callable<String> {//实现Callable接口
@Override
public String call() throws Exception {//该线程需要完成的任务
String value = "test";
System.out.println("Ready to work");
Thread.currentThread().sleep(5000);
System.out.println("Task done");
return value;
}
}public class FutureTaskDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> task=new FutureTask<String>(new MyCallable());
Thread thread = new Thread(task);
Thread.sleep(1000);
thread.start();
if(!task.isDone()){//判断任务是否完成
System.out.println("task has not finish, please wait!");
}
System.out.println("task reutrn : "+ task.get());//get会等待Callable有返回值之后才会返回
}
}五、线程的状态
1、新建（NEW），线程创建后尚未启动的状态，即还未调用start()方法
2、运行(Runnable):包括了Running和Ready。此状态的线程有可能正在执行，也又可能正在等待CPU为它分配执行时间。
3、无限等待(Waiting)：不会被分配CPU执行时间，需要显式被唤醒。
未被设置Timeout参数的Object.wait()和Thread.join方法
4、限期等待(Timed Waiting):在一定时间后会由系统自动唤醒。
设置Timeout参数的Object.wait()和Thread.join方法
5、阻塞(Blocked):等待获取排它锁，例如:synchronized,当一方获取synchronized时，其他对象都要等待这个锁释放，等待的时候会进入阻塞状态。
6、结束：已终止线程的状态，线程已经结束执行
六、sleep和wait的区别
1、基本差别
- sleep()是Thread类的方法，wait()是Object类的方法
- sleep()方法可以在任何地方使用
- wait()方法只能在synchronized方法或synchronized块中使用
2、最主要的本质区别
- Thread.sleep()会让出CPU，不会导致锁行为的改变
- Object.wait()不会让出CPU，还会释放已经占有的同步资源锁
实例一：
public class WaitSleepDemo {
public static void main(String[] args) {
final Object lock = new Object();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Thread A is waiting to get lock.");
synchronized (lock) {
try {
System.out.println("Thread A get lock");
Thread.sleep(20);
System.out.println("Thread A do wait method");
lock.wait(1000);//让出锁10秒，这10秒中B线程获得锁来执行其代码逻辑
System.out.println("Thread A is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Thread B is waiting to get lock.");
synchronized (lock) {
try {
System.out.println("Thread B get lock");
System.out.println("Thread B is sleeping 10 ms");
Thread.sleep(20);
System.out.println("Thread B is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}实例二：
public class WaitSleepDemo {
public static void main(String[] args) {
final Object lock = new Object();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Thread A is waiting to get lock.");
synchronized (lock) {
try {
System.out.println("Thread A get lock");
Thread.sleep(20);
System.out.println("Thread A do wait method");
Thread.sleep(1000);
System.out.println("Thread A is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Thread B is waiting to get lock.");
synchronized (lock) {
try {
System.out.println("Thread B get lock");
System.out.println("Thread B is sleeping 10 ms");
lock.wait(10);
System.out.println("Thread B is done");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}此时A线程没有让出锁，则必须等待A执行完毕释放锁资源，B才会执行
七、notify和notifyall的区别
1、锁池EntryList
假如线程A已经拥有了某个对象的锁，线程B、C想要调用这个对象的synchronized方法，但是B、C线程在进入该方法之前，必须获得该对象的锁拥有权，而A又没有释放锁，此时B、C会进入阻塞状态，进入锁池来等待锁的释放。
2、等待池WaitSet
执行wait方法之后，该线程会进入等待池
notifyAll()会让等待池里所有线程进入锁池，来争夺锁资源
notify()则会随机选取一个出与等待池的线程进入锁池竞争获取锁的机会
八、yield
yield对锁行为没有影响，当调用Thread.yield()函数时，会给线程调度器一个当前线程愿意让出CPU使用的暗示，但是线程调度器可能会忽略这个暗示。
九、interrup函数
调用interrup()，通知线程应该中断了。
1、如果线程处于被阻塞状态，那么线程将立即退出被阻塞状态，并抛出一个interrupException异常。
2、如果线程处于正常活动状态，那么会将该线程的中断标志设置为True，被设置中断标志的线程将继续正常运行，不受影响。
使用方法：
①在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。
②如果线程处于正常活动状态，那么会将该线程的中断标志设置为true，被设置中断标志的线程将继续正常运行，不受影响。
十、FutureTask
1、FutureTask有两个构造器，一个接收Runnable，一个接收Callable
接收Runnable的构造器的目的只有一个，就是把入参都转化成Callable。因为Callable的功能比Runnable丰富。Callable的call方法有返回值，而Runnable的run方法没有。
public FutureTask(Runnable runnable, V result) {
// Executors.callable 方法把 runnable 适配成 RunnableAdapter，RunnableAdapter 实现了 callable，所以也就是把 runnable 直接适配成了 callable。
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
Executor.callable方法来把Runnable转化成Callable。
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}1、首先RunnableAdapter实现了Callable，所以RunnableAdapter就是Callable，，然后就会通过这种适配模式，new RunnableAdapter（Runnable r，T）返回RunnableAdapter对象，进而也就是Runnable变成Callable
2、get方法
无参get会一直等到任务执行完毕才返回。
有参get可以设定固定的时间，如果任务还没有执行成功，直接返回异常。
3、cancel方法主要是用来取消任务，如果任务还没有执行，是可以取消的，如果任务已经在执行过程中了，你可以选择不取消，或者直接打断执行中的任务。
