线程池练习

/*
需求：
        通过查询JDK自带的线程池，学习线程池的使用方法。
        并做以下练习：通过从线程池中获取的线程执行一个多线程任务（任务自定义）。
        想得满分，至少得写出两种线程池的用法，并附带详细的注释。

查阅api
        newFixedThreadPool
                public static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池，
                以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。
                如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。
                如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要
				）。
                在某个线程被显式地关闭之前，池中的线程将一直存在。
        newScheduledThreadPool
                public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，
                它可安排在给定延迟后运行命令或者定期地执行。 

                参数：
                corePoolSize - 池中所保存的线程数，即使线程是空闲的也包括在内。 
                返回：
                        新创建的安排线程池 
思路：
        1.定义一个专门用于操作线程池的类
                类中定义两个方法，分别是线程池的用法
                通过查阅api文档，书写线程池用噶
        2.在main方法，中创建对象， 调用这两个方法
*/
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class ThreadPool 
{
        public static void main(String[] args) 
        {
                ThreadPool tp = new ThreadPool();
                tp.fixedThreadPool();
                try{Thread.sleep(1000);}catch(Exception e){}
                tp.scheduledThreadPool();
                
        }
        public  void fixedThreadPool(){
                ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);//创建一个可重用固定线程数的线
				程池，以共享的无界队列方式来运行这些线程。这里设定的线程数是2
                  for (int i = 0; i < 8; i++) {
                   final int number = i;
                   fixedThreadPool.execute(new Runnable() {//执行execute(Runnable command)  在将来某个时间执行给
				   定任务。任务代码如下run方法中
                        public void run() {
                         try {
                          System.out.println("fixedThreadPool..两个一起执行"+number);
                          Thread.sleep(1000);
                         } catch (InterruptedException e) {
                          fixedThreadPool.shutdown();
                          e.printStackTrace();
                         }
                        }
                   });
                  }
        
        }
        public  void scheduledThreadPool(){
                ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);// 创建一个线程池，它可
				安排在给定延迟后运行命令或者定期地执行。这里延迟的时间设为1

                  for (int i = 0; i < 8; i++) {
                   final int number = i;
                   scheduler.schedule(new Runnable() {//schedule(Runnable command, long delay, TimeUnit unit) 创
				   建并执行在给定延迟后启用的一次性操作。操作的代码如下run方法中run方法中 
                          
            public void run() {
                         try {
                                
                          System.out.println("scheduler。。等待1s在执行"+number);
                          Thread.sleep(1000);
                         } catch (InterruptedException e) {
                          e.printStackTrace();
                         }
                        }}, 3, TimeUnit.SECONDS);

                  }
        
        }
}