Java 线程池

代码实例：           ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

package com.Li.xcchi;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Description: 利用线程池newFixedThreadPool实现多线程
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午12:28:21
 */
public class Test {
  public static void main(String[] args) {    
    //通过Executors 创建一个 newFixedThreadPool线程池
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);   
    //利用线程池创建多线程
    for (int i = 0; i < 10; i++)
    {
      if (!fixedThreadPool.isShutdown()) 
      {
        //内部类 实例runnable
        fixedThreadPool.submit(new Runnable() {
          @Override
          public void run() 
          {
            try {
              //线程睡眠
              Thread.sleep(2000);
              System.out.println("当前的线程名字："+Thread.currentThread().getName());
            } catch (InterruptedException e) {
              System.out.println("当前线程"+Thread.currentThread().getName()+"中断异常");
            }
          }
        });
      }
    }   
    //关闭线程池
    fixedThreadPool.shutdown();
  }
}

package com.Li.xcchi02;
/**
 * @Description: 通过实现Runnable接口实现多线程
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午2:15:32
 */
public class MyThread implements Runnable {
  @Override
  public void run() {
    try {
      Thread.sleep(1000);
      System.out.println("当前线程的名字："+Thread.currentThread().getName());
      //模拟异常
      System.out.println(2/0);
      //中断异常，看是否会补一个线程
    } catch (InterruptedException e) {
      System.err.println("此线程中断："+Thread.currentThread().getName());
    }
  }
}
package com.Li.xcchi02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Description: 测试类 测试线程池SingleThreadExecutor
 * @Description: 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。
 *            如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行
 *             顺序按照任务的提交顺序执行
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午2:23:14
 */
public class Test {
  public static void main(String[] args) {
    //利用Executors 创建   SingleThreadExecutor 线程池
    ExecutorService singlepool = Executors.newSingleThreadExecutor();
    //创建五个线程
    MyThread t1 = new MyThread();
    MyThread t2 = new MyThread();
    MyThread t3 = new MyThread();
    //将任务放到线程池中
    singlepool.execute(t1);
    singlepool.execute(t2);
    singlepool.execute(t3);
    //关闭线程池
    singlepool.shutdown();
  }
}

package com.Li.CachedThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Description: 创建 CachedThreadPool 多线程   用来实现缓存多线程
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午3:05:43
 */
public class Test {
  public static void main(String[] args) throws InterruptedException {
    //创建一个CatchedThreadPool  可缓存的线程池  
    ExecutorService cached = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
      if (!cached.isShutdown()) 
      {       
        Thread.sleep(1000);
        cached.execute(new Runnable() {
          @Override
          public void run() 
          {
            System.out.println("当前线程的名字为："+Thread.currentThread().getName());
          }
        });
      };
    }
    //关闭线程池
    cached.shutdown();
  }
}

package com.Li.TimerTasks;
import java.util.TimerTask;
/**
 * @Description: 定时任务类  
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午3:38:56
 */
public class MyTimerTask extends TimerTask {
  @Override
  public void run() {
    System.out.println("我设定的定时任务就是在控制台输出：你好。。。。。");
  }
}
package com.Li.TimerTasks;
import java.util.Timer;
import java.util.TimerTask;
/**
 * @Description:  测试类    测试JDK中的定时器          定时任务类   
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午3:40:23
 */
public class Test {
  public static void main(String[] args) throws InterruptedException {
    //现在需要一个定时器类
    Timer timer = new Timer();
    //我的定时器任务类
    TimerTask time = new MyTimerTask();
    //定时调度           任务     起始时间    间隔时间
    timer.schedule(time,0 , 2000);
    //线程睡眠
    Thread.sleep(4000);
    //取消定时器
    timer.cancel();
  }
}

package com.Li.ScheduledThreadPool;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * @Description:    ScheduledThreadPool   创建一个定长线程池  ，  支持定时及周期性任务执行
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午4:41:14
 */
public class Test {
  public static void main(String[] args) throws InterruptedException {
    //创建一个定长线程池
    ScheduledExecutorService sched = Executors.newScheduledThreadPool(5);
    //参数的释义         线程任务 、 延迟时间 、 间隔时间 、 时间单位
    sched.scheduleAtFixedRate(new Runnable() {
      @Override
      public void run() {
        System.out.println("当前线程的名字："+Thread.currentThread().getName());
      }
    }, 1, 2, TimeUnit.SECONDS);// 内部 Runnable类     延迟1s 每次间隔2s  时间单位秒
    //主线程休眠5秒
    Thread.sleep(5000);
    //关闭多线程
    sched.shutdown();
  }
}