java中的多线程

  • 简介

  为了给并发程序开发提供更好的支持,java不仅提供了Thread类、Runnable接口等简单的多线程支持工具,还提供了用于多线程管理的线程池,用于提高并发程序的性能。

  • 无限制线程的缺陷

  多线程的软件设计方法确实可以提高多核处理器的计算能力,提高系统的性能和吞吐量,但是如果不加限制的使用多线程,对于系统性能不仅不能提升,反而会下降产生不利影响。

  简单的线程创建方法new Thread().start(),通过thread来启动线程,并且由系统自动的回收线程。在简单的系统这样做并没有问题,但是在真实的生产系统中,在某一时刻会有大量的请求,这样就需要为每一个请求创建一个线程,而当线程数量过大时,会耗尽CPU和内存资源。

  虽然线程是一种轻量级的工具,但是其创建和销毁也需要消耗一定的时间;其次,线程本身也是需要占用内存空间的,大量的线程会抢占内存只有,导致Out of memory异常,并且大量线程的回收会给GC带来很大压力,延长GC停顿的时间。

  因此,对线程的使用必须控制一个度,在适当的范围内使用会提供系统性能,但是,一旦超过了这个范围,大量的线程就会拖垮整个系统。在生产环境下,必须要对其进行管理和控制。

  • 简单线程池的实现

  前面介绍在多线程中不断的创建和销毁线程会带来额外的开销,这样就需要引入一种线程复用机制,即线程池。线程池的基本功能就是进行线程复用,当系统接受一个提交的任务,需要一个线程时,并不急于去创建一个线程,而是去现场池中寻找,是否有闲置的线程,若有,直接使用线程池中的线程工作,如没有,再去创建新的线程。待任务完成后,也不是简单的销毁线程,而是将线程放回线程池中,以便下次复用。

  上面已经把线程池实现的原理简单说明了一下,下面我们自己实现一个线程,来了解一下线程池实现的核心功能,有助于理解线程池的实现。

  线程池实现代码:

 1 public class ThreadPool {
 2     private static ThreadPool instance = null;
 3     //空闲线程队列
 4     private List<PThread> idelThreads;
 5     //已有的线程总数
 6     private int threadCounter;
 7     private boolean isShutdown = false;
 8     
 9     public ThreadPool() {
10         idelThreads = new Vector<PThread>(5);
11         threadCounter=0;
12     }
13 
14     public synchronized int getCreatedThreadsCount() {
15         
16         return threadCounter;
17     }
18     
19     //取得线程池实例
20     public synchronized static ThreadPool getInstatce(){
21         if(instance==null){
22             instance = new ThreadPool();
23         }
24         return instance;
25     }
26     
27     //把线程重新放回到池中
28     
29     public synchronized void repool(PThread repoolThread){
30         if(!isShutdown){
31             idelThreads.add(repoolThread);
32         }else{
33             repoolThread.shutdown();
34         }
35     }
36     
37     //停止池中所有线程
38     public synchronized void shutdown(){
39         isShutdown = true;
40         for (int i = 0; i < idelThreads.size(); i++) {
41             PThread pthread = idelThreads.get(i);
42             pthread.shutdown();
43         }
44     }
45     //执行任务
46     public synchronized void start(Runnable target){
47         PThread pthread = null;
48         //如果有闲置线程
49         if(idelThreads.size()>0){
50             int index = idelThreads.size()-1;
51             pthread=idelThreads.get(index);
52             idelThreads.remove(index);
53             pthread.setTarget(target);
54         }else{//如果没有闲置线程
55             threadCounter++;
56             PThread p = new PThread(instance, target, "PThread#"+threadCounter);
57             p.start();
58         }
59     }
60     
61     
62     
63 }

  从代码中可以看出,线程池中有一个闲置线程的队列,在执行任务时,如果有闲置线程,则从线程池中取线程执行任务,如果没有现在线程,则创建新的线程,并且在现场使用完毕后,会将线程重新放回到闲置线程队列中。

  另外,线程池的使用还需要一个永不退出的线程的配合使用,该线程在手动关闭前永不结束,并且一直等待新任务的到来。代码如下:

 1 public class PThread extends Thread{
 2     //线程池
 3     private ThreadPool pool;
 4     //任务
 5     private Runnable target;
 6     private boolean isShutDown = false;
 7     private boolean isIdle = false;
 8     public PThread(ThreadPool pool, Runnable target,String name) {
 9         super(name);
10         this.pool = pool;
11         this.target = target;
12     }
13     
14     public synchronized Runnable getTarget() {
15         return target;
16     }
17     public synchronized boolean isIdle() {
18         return isIdle;
19     }
20 
21     @Override
22     public void run() {
23         
24         while(!isShutDown){
25             isIdle = false;
26             
27             if(target!=null){
28                 //运行任务
29                 target.run();
30             }
31             //任务结束,闲置任务
32             isIdle=true;
33             
34             try {
35                 pool.repool(this);
36                 synchronized (this) {
37                     //线程闲置,等待任务到来
38                     wait();
39                 }
40             } catch (Exception e) {
41                 // TODO: handle exception
42             }
43             
44             isIdle=false;
45         }
46     
47     }
48     
49     public synchronized void setTarget(Runnable target){
50         this.target=target;
51         //设置任务之后,通知run方法,开始执行
52         notifyAll();
53     }
54     
55     public synchronized void shutdown(){
56         isShutDown=true;
57         notifyAll();
58     }
59     
60     
61 }

  执行线程:

 1 public class MyThread implements Runnable{
 2     
 3     
 4     private String name;
 5     
 6     
 7     
 8     public MyThread() {
 9         
10     }
11 
12 
13     public MyThread(String name) {
14         this.name = name;
15     }
16 
17 
18     @Override
19     public void run() {
20         // TODO Auto-generated method stub
21         try {
22             Thread.sleep(1000);
23         } catch (InterruptedException e) {
24             // TODO Auto-generated catch block
25             e.printStackTrace();
26         }
27     }
28     
29 }

  测试代码:

 1 public class TestClient {
 2     public static void main(String[] args) {
 3         
 4         ExecutorService executor = Executors.newCachedThreadPool();
 5         
 6         long begin = System.currentTimeMillis();
 7         
 8         for (int i = 0; i < 1000; i++) {
 9             //new Thread(new MyThread("testnopoolThread"+i)).start();
10             
11             ThreadPool.getInstatce().start(new MyThread("testpoolThread"+i));
12             
13             //executor.execute(new MyThread("executorpoolThread"+i));
14         }
15         
16         System.out.println(System.currentTimeMillis()-begin);
17     
18     }
19 }

   线程池能减少线程频繁调度的开销,线程的复用,对系统性能的提升效果比较明显。

  • Executor框架

  JDK提供了一整套的Executor框架,帮助开发人员有效的进行线程控制。ThreadPoolExecutor表示一个线程池,Executors类扮演着线程池工厂的角色,通过Executor可以取得一个特定功能的线程池。

  newFixedThreadPool():该方法返回一个固定线程数量的线程池,该线程池中线程的数量始终保持不变。当一个任务提交后,线程池中若有空闲线程则立即执行,若没有,新任务会被保存在一个任务队列中,待有现车空闲时,便处理任务队列中的任务。

  newSingleThreadExecutor():该方法返回只有一个线程的线程池。若多余的任务被提交到该线程池,任务会被保存到一个任务队列中,若线程空闲,按先进先出的顺序执行队列中的任务。

  newCacheThreadPool():该方法返回一个根据实际情况调整线程数量的线程池。若有空闲线程可以复用,则优先选择使用可复用的线程,否则,创建新的线程处理新任务。

  newSingleThreadScheduledExecutor()方法:该方法返回一个ScheduledExecutorService对象,线程池大小为1,在给定时间内执行某一任务。

  • 自定义线程池

  newFixedThreadPool、newSingleThreadExecutor、newCacheThreadPool的内部实现都实现了ThreadPoolExecutor。在ThreadPoolExecutor中有一个最主要的构造函数:

 1 public ThreadPoolExecutor(int corePoolSize,
 2                               int maximumPoolSize,
 3                               long keepAliveTime,
 4                               TimeUnit unit,
 5                               BlockingQueue<Runnable> workQueue,
 6                               ThreadFactory threadFactory,
 7                               RejectedExecutionHandler handler) {
 8         if (corePoolSize < 0 ||
 9             maximumPoolSize <= 0 ||
10             maximumPoolSize < corePoolSize ||
11             keepAliveTime < 0)
12             throw new IllegalArgumentException();
13         if (workQueue == null || threadFactory == null || handler == null)
14             throw new NullPointerException();
15         this.corePoolSize = corePoolSize;
16         this.maximumPoolSize = maximumPoolSize;
17         this.workQueue = workQueue;
18         this.keepAliveTime = unit.toNanos(keepAliveTime);
19         this.threadFactory = threadFactory;
20         this.handler = handler;
21     }

  corePoolSize:线程池中核心线程的数量;

  maximumPoolSize:线程池中最大线程的数量;

  keepAliveTime:当线程池中的线程数量超过corePoolSize时,多余的空闲线程的存活时间;

  unit:keepAliveTime的单位;

  workQueue:任务队列,提交但是尚未执行的任务;

  threadFactory:线程工厂,用于创建线程;

  hander:拒绝策略,当任务太多时,怎么拒绝任务。

  主要来介绍下workQueue和hander:

  workQueue任务队列,提交但是尚未执行的任务,主要由以下几种实现方式:

  直接提交的队列:该功能由SynchronousQueue对象提供。SynchronousQueue是一个特殊的BlockingQueue,它没有容量,每当插入操作都要等待响应的删除操作,反之,每当删除操作斗鱼等待线程插入操作。它不保证任务,总是将任务提交给线程来执行,如果没有空闲线程,则创建新的线程,当线程数达到最大数值时,则执行拒绝策略。因此,如果使用SynchronousQueue,通常会设置很大的maximumPoolSize,否则很容易执行拒绝策略。

  有界任务队列:当使用有界任务队列,若有新的任务需要执行,如果线程池的实际线程数小于corePoolSize,则会创建新的线程,若大于corePoolSize,则将新任务加入到等待队列中,若任务队列已满,无法加入,则在总数不大于maximumPoolSize的前提下,创建新的线程执行。若大于maximumPoolSize,则执行拒绝策略。如ArrayBlockingQueue队列。

  无界任务队列:于有界任务队列相比,除非耗尽系统资源,否则不会出现任务放入任务队列失败的情况。当有新的任务到来时,系统的线程数小于corePoolSize,线程池就会产生新的线程执行任务。当系统的线程数达到corePoolSize,就不再增加。如后续仍有新的任务产生,但是没有空闲的线程资源,那么线程进入任务队列进行等待。如:LinkedBlockingQueue队列。

  优先任务队列:优先任务队列是带有执行优先级的队列。可以控制任务的执行顺序,是一个特殊的无界队列。如PriorityBlockingQueue队列。PriorityBlockingQueue可以根据任务自身的优先级顺序先后执行,在确保系统性能的同时,也能有很好的质量保证。线程要实现comparable接口。

  hander是线程池的拒绝策略:

  JDK内置的拒绝策略如下:

  AbortPolicy策略:该策略会直接抛出异常,阻止系统的正常工作。

  CallerRunsPolicy策略:只要线程池未关系,该策略直接在调用者线程中,运行当前被丢弃的任务。

  DiscardOledestPolicy策略:该策略将丢弃最老的一个请求,尝试再次执行提交当前任务。

  DiscardPolicy策略:该策略丢弃无法处理的任务,不予以任何处理。

  在JDK所提供的线程池不能满足需求的时候,可以考虑实现自定义的线程池,自定义的线程池可以提供更为灵活的任务处理和调度方式。

  • 扩展ThreadPoolExecutor

  ThreadPoolExecutor是一个可扩展的线程池,它提供了beforeExecute()、afterExecute()和terminated()三个方法实现对线程池的控制。

  在默认的ThreadPoolExecutor实现中,提供了空的beforeExecute()、afterExecute()的实现。在实际应用中,可以对其进行扩展,实现对线程池状态的跟踪,输出一些有用的调试信息,以帮助系统故障诊断。

  下面就是一个带有日志输出功能的线程池,该线程池会在任务执行前输入任务执行的名称和id,同时,在任务执行完毕后,可以输出线程的id和当前线程池的线程数量。

  

 1 public class MyThreadPoolExecutor extends ThreadPoolExecutor{
 2 
 3     public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
 4             long keepAliveTime, TimeUnit unit,
 5             BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
 6             RejectedExecutionHandler handler) {
 7         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 8                 threadFactory, handler);
 9     }
10 
11     @Override
12     protected void beforeExecute(Thread t, Runnable r) {
13         System.out.println("BeforeExecute MyThread name:"+((MyThread)r).getName()+"ID: "+t.getId() );
14     }
15 
16     @Override
17     protected void afterExecute(Runnable r, Throwable t) {
18         System.out.println("AfterExecute MyThread ID:"+Thread.currentThread().getId());
19         System.out.println("AfterExecute Poolsize:"+this.getPoolSize());
20     }
21     
22     
23     
24 }

 

  

  

    原文作者:ngulc
    原文地址: https://www.cnblogs.com/lcngu/p/5331045.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞