多线程复习一

1、创建多线程

1. 继承Thread类，重写 run（）方法

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0) System.out.println(this.getName());
        }
    }

2. 实现Runnable接口，重写run()方法，将这个实例传入Thread类

 public static void main(String[] args) {
        Thread thread = new Thread(new Task());
        //start调用thread的run()，thread的run()又调用了Task的run()
        thread.start();
  }
  
class Task implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

推荐使用实现runnable接口：

• 解决类的单继承问题。
• 多线程共享数据更适合处理

注意：Thread类也实现了runnable接口，其中的run()方法也是实现runnable接口的

---

3. 实现Callable接口,重写call方法

相对于实现Runnable接口，Callable更加强大
1、Callable可以有返回值
2、可以抛出异常
3、支持泛型的返回值
4、需要借助FutureTask类，比如返回结果

Future接口

• Future是一个接口，代表了一个异步计算的结果。接口中的方法用来检查计算是否完成、等待完成和得到计算的结果。
• 当计算完成后，只能通过get()方法得到结果，get方法会阻塞直到结果准备好了。
• 如果想取消，那么调用cancel()方法。其他方法用于确定任务是正常完成还是取消了。
• 一旦计算完成了，那么这个计算就不能被取消。

FutureTask类

• FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口，所以说FutureTask是一个提供异步计算的结果的任务。
• FutureTask可以用来包装Callable或者Runnbale对象。因为FutureTask实现了Runnable接口，所以FutureTask也可以被提交给Executor。

public class ThreadLearning{

    public static void main(String[] args){
       Num num = new Num();
       FutureTask<Integer> futureTask = new FutureTask<>(num);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
        //获取call方法的返回值
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Num implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 101; i++) {
            sum += i;
        }
        return sum;
    }
}

步骤：

1. 实现Callable接口
2. 创建FutureTask类，传入Callable接口的实现类
3. 创建线程，传入FutureTask类的实例
4. 启动线程

4、创建线程池

避免重复、销毁创建线程。提高了响应速度，减少了资源消耗。
Java通过Executors提供四种线程池

• CachedThreadPool()：可缓存线程池。线程数无限制
  有空闲线程则复用空闲线程，若无空闲线程则新建线程 一定程序减少频繁创建/销毁线程，减少系统开销

• FixedThreadPool()：定长线程池。可控制线程最大并发数（同时执行的线程数）。超出的线程会在队列中等待

• ScheduledThreadPool()：定时线程池。支持定时及周期性任务执行。

• SingleThreadExecutor()：单线程化的线程池。有且仅有一个工作线程执行任务
  所有任务按照指定顺序执行，即遵循队列的入队出队规则

public class Test001 {
    public static void main(String[] args) {
        //1.创建可固定长度的线程池
        ExecutorService newExecutorService = Executors.newFixedThreadPool(10);
        //创建了10个任务
        for (int i = 0; i < 10; i++) {
            int temp = i;
            newExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
                }
            });
          
        }
		executorService.shutdown();
    }
}

线程池有两个方法，用于执行任务

• void execute(Runnable command)：常用于执行Runnable任务
• Future<?> submit(Runnable task 或 Callable task)：常用于执行Callable任务

PS:线程池使用完毕后，记得关闭线程池executorService.shutdown();

2、方法

1. public void start() ： 调用该线程，并且让jvm调用Thread类及子类的run()方法
2. public static void yield()：暗示调度器当前线程愿意暂停执行，从而让其他等待线程获取执行权。（但是执行后，其他线程不一定能获取执行权）
3. public void join() ：在线程A调用线程B对象的join方法时，线程A将被阻塞，
   直到线程B运行完（低优先级的线程也可以获得执行），再次执行。
4. public static void sleep(long millis)：让当前线程休眠。注意：sleep方法只是让出了cpu的执行权，并不会释放同步资源锁。

3、线程的生命周期

1、就绪、运行、阻塞的区别

就绪：可以被cpu调度
运行：正在被cpu调度
阻塞：无法被cpu调度

4、线程的调度

1、线程调度策略

线程的调度有两种策略：

• 时间片：线程之间交互使用cpu
• 抢占式：高优先级的线程抢占cpu

相同优先级的线程组成队列，使用时间片策略

不同优先级的线程之间采用抢占式策略，高优先级的优先调度。

2、线程的优先级

    /**
     * The minimum priority that a thread can have.
     */
    public static final int MIN_PRIORITY = 1;

    /**
     * The default priority that is assigned to a thread.
     */
    public static final int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public static final int MAX_PRIORITY = 10;

3、优先级set、get方法

• public final void setPriority( int newPriority )
• public final int getPriority()

4、注意点

• 线程创建时继承父线程的优先级
• 线程的优先级只是表示获得调度的概率大小，低优先级获得调度的概率小，高优先级大。所以低优先级不一定比高优先级晚调度。