Java基础之线程池 - 潇湘剑雨

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源，在使用线程池之前，必须知道如何去创建一个线程池，在Java中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的

一、固定大小的线程池

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

/** 
* Java线程：线程池- 
* 
*/ 
public class Test {
        public static void main(String[] args) {
                //创建一个可重用固定线程数的线程池
                ExecutorService pool = Executors.newFixedThreadPool(4); 
                //创建实现了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(); 
        } 
} 

class MyThread extends Thread{ 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName()+"正在执行。。。");
        } 
}

二、单任务线程池

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

/** 
* Java线程：线程池- 
* 
*/ 
public class Test {
        public static void main(String[] args) {
                //创建一个单任务的线程池
                ExecutorService pool = Executors.newSingleThreadExecutor();
                //创建实现了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(); 
        } 
} 

class MyThread extends Thread{ 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName()+"正在执行。。。");
        } 
}

三、可变尺寸的线程池

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

/** 
* Java线程：线程池- 
* 
*/ 
public class Test {
        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(); 
        } 
} 

class MyThread extends Thread{ 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName()+"正在执行。。。");
        } 
}

四、延迟连接池

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

/** 
* Java线程：线程池- 
* */ 
public class Test {
        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(); 
        } 
} 

class MyThread extends Thread { 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        } 
}

五、单任务延迟连接池

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

/** 
* Java线程：线程池- 
* */ 
public class Test {
        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(); 
        } 
} 

class MyThread extends Thread { 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        } 
}

六、自定义线程池

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

/** 
* Java线程：线程池-自定义线程池
* 
*/ 
public class Test {
        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(); 
        } 
} 

class MyThread extends Thread { 
        @Override 
        public void run() {
                System.out.println(Thread.currentThread().getName() + "正在执行。。。");
                try {
                        Thread.sleep(100L); 
                } catch (InterruptedException e) {
                        e.printStackTrace(); 
                } 
        } 
}

发表于 2016-09-02 15:03 潇湘剑雨阅读(163) 评论(0) 编辑收藏举报