##线程面试题##

一.java中线程实现几种实现方式 在Java中实现多线程一共有四种方式： （1）继承Thread类 （2）实现Runable接口 （3）实现Callable接口 （4）线程池 1.继承java.lang.Thread，重写run方法，启动线程，调用start（）方法> 2.实现java.lang.Runnable接口，实现run方法 3.实现Callable接口（JDK8新特性） 该方法效率较低，因为在获取线程的执行结果的时候，当前线程受阻塞。但是可以拿到线程的返回结果。call（）方法相当于run方法 call方法能向上抛出异常 Runnable是执行工作的独立任务，但是不返回任何值。如果我们希望任务完成之后有返回值，可以实现Callable接口。 FutureTask类提供了一个get（）方法用来获取call（）方法的返回值，但需要注意的是调用这个方法会导致程序阻塞，必须要等到线程结束后才会得到返回值。 public Object call() throws Exception { return object 类型; } 4，采用匿名内部类的方式

Thread thread=new Thread(new Runnable()
{
@Override
public void run()
 {  
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName());
  }
});
thread.start();

5.线程池 在Java中构建一个新的线程是需要一定的系统开销的，前面三种实现多线程的方法在线程执行完任务后就会将线程销毁， 那么是否可以在线程执行完任务后将线程保存下来，给下一个任务使用呢？答案是可以的，为了解决这个问题，线程池应运而生。 顾名思义，线程池就是用来存储线程的池子。线程池中包含许多准备运行的线程，我们只需要为线程池提供一个个任务， 线程池就会按照一定的规则去调用这些任务，当一个任务完成后，调用这个任务的线程不会死亡， 而是留在线程池中准备为下一个任务提供服务。 Executors类提供了许多静态工厂方法用来构造线程池，这里我介绍其中的三种： 1.newFixedThreadPool(int nThreads) 该方法用来构造一个固定大小的线程池，空闲的线程会一直保留着，如果提交的任务数多于空闲线程数，就会把未得到服务的任务放到队列中等待

public class MyFixedThreadPool {
   public static void main(String[] args) throws ExecutionException, InterruptedException {
       ExecutorService executorService = Executors.newFixedThreadPool(3);
       // 调用 Runnable 任务
       TestRunnable1 testRunnable1 = new TestRunnable1();
       for (int i = 0; i < 5; i++) {
             // 调用 Runnable 任务可以用以下两种方法，二者的区别在于前者没返回值，后者有返回值
           //第一种方法
       	executorService.execute(testRunnable1);
       	 //第二种方法
           Future<?> submit = executorService.submit(testRunnable1);
       }
       // 调用 Callable 任务
       TestCallable1 testCallable1 = new TestCallable1();
       for (int i = 0; i < 5; i++) {
           // 调用 Callable 任务只能用这一种方法
           Future<Integer> submit = executorService.submit(testCallable1);
           System.out.println("返回值：" + submit.get());
       }
   }
 }
   class TestRunnable1 implements Runnable {
   @Override
   public void run() {
       System.out.println("我是 Runnable 任务，调用我的线程是：" + Thread.currentThread().getName());
   }
  }
class TestCallable1 implements Callable<Integer> {
   @Override
   public Integer call() throws Exception {
       System.out.println("我是 Callable 任务，调用我的线程是：" + Thread.currentThread().getName());
       return 666;
   }
  }

2.newCachedThreadPool() 该方法构建的线程池会立即执行任务，如果当前存在空闲线程，则直接执行任务；如果当前不存在空闲线程，则创建一个新线程执行任务。在该线程池内空闲线程只会保留60秒

public class MyCachedThreadPool {
   public static void main(String[] args) throws ExecutionException, InterruptedException {
       ExecutorService executorService = Executors.newCachedThreadPool();
       // 调用 Runnable 任务
       TestRunnable2 testRunnable2 = new TestRunnable2();
       for (int i = 0; i < 5; i++) {
           // 调用 Runnable 任务可以用以下两种方法，二者的区别在于前者没返回值，后者有返回值
           executorService.execute(testRunnable2);
           Future<?> submit = executorService.submit(testRunnable2);
       }
       // 调用 Callable 任务
       TestCallable2 testCallable2 = new TestCallable2();
       for (int i = 0; i < 5; i++) {
           // 调用 Callable 任务只能用这一种方法
           Future<Integer> submit = executorService.submit(testCallable2);
           System.out.println("返回值：" + submit.get());
       }
   }
}
 class TestRunnable2 implements Runnable {
   @Override
   public void run() {
       System.out.println("我是 Runnable 任务，调用我的线程是：" + Thread.currentThread().getName());
   }
 }

class TestCallable2 implements Callable<Integer> {
   @Override
   public Integer call() throws Exception {
       System.out.println("我是 Callable 任务，调用我的线程是：" + Thread.currentThread().getName());
       return 666;
   }
}

3.newSingleThreadExecutor() 该方法构建的线程池只存在一个线程，会顺序地执行所提交的任务。

public class MySingleThreadExecutor {
public static void main(String[] args) throws ExecutionException, InterruptedException {
       ExecutorService executorService = Executors.newSingleThreadExecutor();
      
 // 调用 Runnable 任务
TestRunnable3 testRunnable3 = new TestRunnable3();
       for (int i = 0; i < 5; i++) {
           // 调用 Runnable 任务可以用以下两种方法，二者的区别在于前者没返回值，后者有返回值
           executorService.execute(testRunnable3);
           Future<?> submit = executorService.submit(testRunnable3);
       }
       // 调用 Callable 任务
       TestCallable3 testCallable3 = new TestCallable3();
       for (int i = 0; i < 5; i++) {
           // 调用 Callable 任务只能用这一种方法
           Future<Integer> submit = executorService.submit(testCallable3);
           System.out.println("返回值：" + submit.get());
       }
   }
}  

class TestRunnable3 implements Runnable 
{
   @Override
   public void run() {
       System.out.println("我是 Runnable 任务，调用我的线程是：" + Thread.currentThread().getName());
   }
 }

class TestCallable3 implements Callable<Integer> {
   @Override
public Integer call() throws Exception {
       System.out.println("我是 Callable 任务，调用我的线程是：" + Thread.currentThread().getName());
       return 666;
   }
 }