初识多线程

package executors_test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Executors_test {

    public static void main(String[] args) {

        
        scheduledThreadPoolExecutorTest();
    }



    /**
     * ScheduledThreadPoolExecutor类可用于定时启动线程，以及周期启动线程
     */
    public static void scheduledThreadPoolExecutorTest() {
        ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(2, new MyRejectedExecutionHandler());
        pool.scheduleAtFixedRate(new MyThread(5), 10000,1000,TimeUnit.MILLISECONDS);
    }



    /**
     * ThreadPoolExecutor类实现的多线程
     */
    public static void threadPoolExecutorTest() {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 2,TimeUnit.MINUTES, new ArrayBlockingQueue<Runnable>(4),new MyRejectedExecutionHandler());
        for (int i = 0; i < 100; i++) {
            threadPoolExecutor.execute(new MyThread(i));
        }
    }

    
    
    /**
     * Executors工厂类实现的多线程,
     */
    public static void newFixedThreadPoolTest(){
        ExecutorService executors = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            executors.execute(new MyThread(i));
        }
    };
    /**
     * Executors工厂类实现的多线程,可用于定时启动线程，以及周期启动线程
     */
    public static void newScheduledThreadPoolTest(){
        ScheduledExecutorService executors = Executors.newScheduledThreadPool(2);
        executors.scheduleAtFixedRate(new MyThread(5), 10000,1000,TimeUnit.MILLISECONDS);
    }
    
    
    static class MyThread implements Runnable {
        int id;

        public MyThread(int id) {
            this.id = id;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"........"+id);
        }
    }
    
    static class MyRejectedExecutionHandler implements RejectedExecutionHandler{
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println(r.toString()+"");
        }
    }
}