【JAVA】 线程相关

1. 进程和线程之间有什么不同？

• 进程是一个独立的运行环境，系统会给每个进程分配独立的内存空间；
• 一个进程下多个线程，共用进程的 内存空间；

 

2.如何创建一个线程？

1.第一种是继承Thread类  实现方法run()  不可以抛du异常 无返值

2.第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返值

3.第三种是实现Callable<T>接口,接口中要覆盖的方法是 public <T> call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值  

   static class MyThread extends Thread {
        @Override
        public void run() {
           ...
        }
    }

    static class MyRun implements Runnable {
       @Override
       public void run() {
            ...
        }
    }

    static class MyCall implements Callable<String> {
        @Override
        public String call() {
            ...
            return "success";
        }
    }

 

3. 线程的状态

• 初始状态，编程语言层面被创建，操作系统线程没有创建。
• 可运行状态，操作系统线程已经被成功创建，但未分配CPU。
• 运行状态，可运行状态的线程被分配CPU的状态就转换成了运行状态。
• 休眠状态， 运行状态的线程调用一个阻塞的API或者等待某个事，状态就会转换到休眠状态，同时释放CPU使用权。休眠状态的线程永远没有机会获得CPU使用权。当等待的事件出现了，线程就会从休眠状态转换到可运行状态。
• 终止状态，线程执行完或者出现异常就会进入，终止状态的线程不会切换到其他任何状态，进入终止状态也就意味着线程的生命周期结束了。

 

线程池

https://www.jianshu.com/p/5c688d14188a

 

1.new Thread的弊端：

new Thread的弊端如下：

• 每次new Thread新建对象性能差。
• 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
• 缺乏更多功能，如定时执行、定期执行、线程中断。

2.Java提供的Executor 线程池好处：

• 重用存在的线程，减少对象创建、消亡的开销，性能佳。
• 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
• 提供定时执行、定期执行、单线程、并发数控制等功能。

 

3.Executor 线程池

Java通过Executors提供四种线程池，分别为：

3.1 newCachedThreadPool

• 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
   

  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
      final int index = i;
      try {
          Thread.sleep(index * 1000);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  
      cachedThreadPool.execute(new Runnable() {
  
          @Override
          public void run() {
              System.out.println(index);
          }
      });
  }

   

3.2 newFixedThreadPool

• 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {


        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字：

• t = 0 时，for循环就运行完毕，fixedThreadPool.execute 执行了10次， 前3次Runnable 被加入线程池，后7次Runnable 在线程池外等待；

• t = 2时， 前3次Runnable运行完毕，各打印1个数字，共3个；开始运行第4，5，6个Runnable；

• ExecutorService.execute 被调用后会立即返回，和其执行的Runnable 是否运行完无关；
• 线程池最大并发数最好通过 Runtime.getRuntime().availableProcessors() 获取：返回可用处理器个数；

 

3.3 newScheduledThreadPool

创建一个定长线程池，支持定时、延时及周期性任务执行。

1.延时执行：schedule()

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);

• 从执行schedule 后的 延长时间后执行Runnable；
• 调用schedule函数后就会立可返回；

2.定时执行：scheduleAtFixedRate()

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 @Override
	public void run() {
		System.out.println("delay 1 seconds, and excute every 3 seconds");
	}
}, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒执行一次。

 

3.4 newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

• 现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

4.Executor  和 Timer的区别：

• Timer的内部只有一个线程，如果有多个任务的话就会顺序执行，这样我们的延迟时间和循环时间就会出现问题。
• ScheduledExecutorService是线程池，所以就不会出现这个情况，在对延迟任务和循环任务要求严格的时候，就需要考虑使用ScheduledExecutorService了。