【java】线程池

在java语言中，可以通过new Thread的方法来创建一个新的线程执行任务，但是线程的创建是非常耗时间的，而且创建出来的新的线程都是各自运行，缺乏统一的管理，这样做的后果是可能
导致创建过多的线程从而过度消耗系统的资源，最终导致性能急剧下降，线程池的引入就是为了解决这些问题的
当使用线程池控制线程数量的时候，其他线程排队等候，当一个任务执行完毕后，再从队列中取出最前面的任务开始执行。如果队列中没有等待进程，那么线程池中的这一资源会处于等待状态。
当一个新任务需要运行的说，如果线程中有等待的工作线程，就可以运行了，否则，进入等待队列
一方面，线程池中的线程可以被所有工作线程重复利用，一个线程可以用来执行多个任务，这样做可以减少了线程创建的次数；另外一方面，它也可以限制线程的个数，从而导致创建过多的线程进而导致性能下降。
当需要执行任务的个数大于线程池中线程的个数的时候，线程池会把这些任务放到队列中，一旦有任务运行结束，就会有空闲的线程，这个时候线程池就会从队列里面取出任务继续执行

package Synchronize;
/**
 * 创建一个单线程的线程池，它只会用唯一的工作线程来执行任务，也就是相当于单线程执行串执行所有任务，
 * 如果这个唯一的线程因为异常结束，那么会有一个新的线程来代替它
 * */

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyThread extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getId()+"run");
    }
}

public class TestSingleThreadExecutor {
    public static void main(String[] args){
        ExecutorService executorService= Executors.newSingleThreadExecutor();
        //将线程放入池中进行执行
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        //关闭线程池
        executorService.shutdown();
    }
}

/*
12run
12run
12run
12run
* */

package Synchronize;

/**
 * 创建一个定长的线程池，可以控制线程的最大并发数目，超出的线程会在队列中等待。
 * 使用这个线程池的时候，必须根据实际情况估算出线程的数量
 * */
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread2 extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getId()+"run");
    }
}

public class TestNewFixedThreadPool {
    public static void main(String[] args){
        ExecutorService executorService= Executors.newFixedThreadPool(2);
        //将线程放入池中进行执行
        executorService.execute(new MyThread2());
        executorService.execute(new MyThread2());
        executorService.execute(new MyThread2());
        executorService.execute(new MyThread2());
        //关闭线程池
        executorService.shutdown();
    }
}

/*
14run
14run
14run
12run
* */

package Synchronize;

/**
 * 创建一个可以缓存线程池，如果线程池的长度超过处理的需要，可以灵活回收空闲线程，如果不可回收的话，则新建线程。此线程池不会对线程的大小做限制
 * 线程池的代销完全依赖于操作系统或者是jvm能够创建的最大线程代销。
 * 使用这种方式需要在代码运行的过程中通过控制并发任务的数量来控制线程的数量
 * */
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread3 extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getId()+"run");
    }
}

public class TestnewCoachedThreadPool {
    public static void main(String[] args){
        ExecutorService executorService= Executors.newCachedThreadPool();
        //将线程放入池中进行执行
        executorService.execute(new MyThread3());
        executorService.execute(new MyThread3());
        executorService.execute(new MyThread3());
        executorService.execute(new MyThread3());
        //关闭线程池
        executorService.shutdown();
    }
}

/*
14run
12run
16run
18run
* */

package Synchronize;

/**
 * 创建一个定长的线程池。此线程池支持定时以及周期性执行任务的需求
 * */
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class MyThread4 extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getId()+"timestamp"+System.currentTimeMillis());
    }
}

public class TestnewScheduledThreadPool {
    public static void main(String[] args){
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor=new ScheduledThreadPoolExecutor(2);
       //每隔一段时间执行一次
        scheduledThreadPoolExecutor.scheduleAtFixedRate(new MyThread4(),0,3000, TimeUnit.MILLISECONDS);
        scheduledThreadPoolExecutor.scheduleAtFixedRate(new MyThread4(),0,3000,TimeUnit.MILLISECONDS);
    }
}