线程池

Posted 2020-09-19 Ipeter

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。
当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
demo1:固定大小的线程池
package com.js.ai.modules.pointwall.interfac;

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

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	ExecutorService pool=Executors.newFixedThreadPool(2);//创建一个可重用固定线程数的线程池 
	 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	pool.execute(t4);
	pool.execute(t5);
	 //关闭线程池
	pool.shutdown();
}
}
demo2:单任务线程池
package com.js.ai.modules.pointwall.interfac;

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

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	ExecutorService pool=Executors.newSingleThreadExecutor();//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
	 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	pool.execute(t4);
	pool.execute(t5);
	 //关闭线程池
	pool.shutdown();
}
}
对于demo1和demo2两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则入此线程池需要排队等待。
一旦池中有线程完毕，则排队等待的某个线程会入池执行。
demo3:可变尺寸的线程池
package com.js.ai.modules.pointwall.interfac;

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

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	ExecutorService pool=Executors.newCachedThreadPool(); //创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
	 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	pool.execute(t4);
	pool.execute(t5);
	 //关闭线程池
	pool.shutdown();
}
}
demo4:延迟连接池
package com.js.ai.modules.pointwall.interfac;


import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	//创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
	ScheduledExecutorService pool=Executors.newScheduledThreadPool(2); 
	 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	//使用延迟执行风格的方法 
	pool.schedule(t4,10,TimeUnit.MILLISECONDS);
	pool.schedule(t5,10,TimeUnit.MILLISECONDS);
	 //关闭线程池
	pool.shutdown();
}
}

　　

demo5:单任务延迟连接池
package com.js.ai.modules.pointwall.interfac;


import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	 //创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
	ScheduledExecutorService pool=Executors.newSingleThreadScheduledExecutor(); 
	 //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	//使用延迟执行风格的方法 
	pool.schedule(t4,10,TimeUnit.MILLISECONDS);
	pool.schedule(t5,10,TimeUnit.MILLISECONDS);
	 //关闭线程池
	pool.shutdown();
}
}

　　

demo6:自定义线程池
package com.js.ai.modules.pointwall.interfac;


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class MyThread extends Thread{
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"正在执行。。");
	}
}
public class ThreadPoolTest {
public static void main(String[] args) {
	//创建等待队列
	BlockingQueue<Runnable> bqueue=new ArrayBlockingQueue<Runnable>(20);
	//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。 
	ThreadPoolExecutor pool=new ThreadPoolExecutor(2, 3, 2, TimeUnit.MILLISECONDS, bqueue);
	//创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
	Thread t1=new MyThread();
	Thread t2=new MyThread();
	Thread t3=new MyThread();
	Thread t4=new MyThread();
	Thread t5=new MyThread();
	Thread t6=new MyThread();
	Thread t7=new MyThread();
	//将线程放入池中进行执行
	pool.execute(t1);
	pool.execute(t2);
	pool.execute(t3);
	pool.execute(t4);
	pool.execute(t5);
	pool.execute(t6);
	pool.execute(t7);
	 //关闭线程池
	pool.shutdown();
}
}