线程池，以及匿名内部类实现多线程

JDK5新增了一个Executors工具类来产生线程池，有如下几个方法
    public static ExecutorService newCachedThreadPool()
    public static ExecutorService newFixedThreadPool(int nThreads)
    public static ExecutorService newSingleThreadExecutor()
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
    Future<?> submit(Runnable task)
    <T> Future<T> submit(Callable<T> task)
案例演示
    创建线程池对象
    创建Runnable实例
    提交Runnable实例
    关闭线程池

匿名内部类方式使用多线程
    new Thread(){代码…}.start();
    New Thread(new Runnable(){代码…}).start();


package com.shujia.day20;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    java提供了一个工具类：Executors让我们获取对应线程池

    开发中常用的线程池是固定大小的线程池：
        static ExecutorService newFixedThreadPool(int nThreads) 创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。

    三种实现线程的方式：
        1、继承Thread类，重写run方法，创建该类的对象并启动
        2、实现Runnable接口，实现run方法，借助Thread类创建线程对象并启动
        3、实现Callable接口，实现call方法，借助线程池使用
 */

class MyRunnable1 implements Runnable {
    private String name;

    public MyRunnable1(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            Thread t1 = Thread.currentThread();//获取当前线程的对象
            t1.setName(name);//获取当前线程的名字
            System.out.println(t1.getName() + " - " + i);
        }
    }
}

class MyCallable implements Callable<Object>{
    private String name;

    public MyCallable(String name) {
        this.name = name;
    }

    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 10; i++) {
            Thread t1 = Thread.currentThread();
            t1.setName(name);
            System.out.println(t1.getName() + " - " + i);
        }
        return null;
    }
}

public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);

//        pool.submit(new MyRunnable1("魏一民")); // 相当于底层给我们将任务封装成了一个线程对象，并启动
//        pool.submit(new MyRunnable1("陈真")); // 相当于底层给我们将任务封装成了一个线程对象，并启动
//        //超过线程池大小的线程，也会执行，只不过是等待前面有线程执行结束后，才能执行
//        pool.submit(new MyRunnable1("李建国")); // 相当于底层给我们将任务封装成了一个线程对象，并启动
//
//        pool.submit(new MyCallable("魏一民"));
//        pool.submit(new MyCallable("陈真"));
//        pool.submit(new MyCallable("李建国"));

        pool.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    Thread t1 = Thread.currentThread();
                    System.out.println(t1.getName() + " - " + i);
                }
            }
        });

        pool.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 1000; i++) {
                    System.out.println(Thread.currentThread().getName() + " - " + i);
                }
            }
        });

        //关闭线程池
//        pool.shutdown();
    }
}