Java_多线程(线程池 )

线程池

我们在项目中往往会创建线程以方便使用,但如果在并发的线程数量多,并每个线程都执行一个时间很短的任务就结束时,就会频繁的创建线程,这样会降低系统的效率拖慢运行时间.在java中我们有更好的办法来实现这样的效果,就是线程池.

利用线程池的好处:

• 降低资源的消耗,通过重复利用已创建的线程降低线程创建和销毁造成的销毁.
• 提高响应速度,当任务到达时,任务可以不需要等线程创建就能立即执行.
• 提高线程的可管理性,线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配.

java通过EXecutors提供了四种线程池

• newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程.
• newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待.
• newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行.
• newSingleThreadExecutor创建一个单程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行.

newCachedThreadPool

java代码

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;


public class Test1 {
   public static void main(String[] args) throws InterruptedException {
      Executor ex = Executors.newCachedThreadPool();
      
      for (int i = 0; i < 10; i++) {
          final int index = i;
        Thread.sleep(index * 1000);
         new Thread(new Runnable() {
                
                @Override
                public void run() {
                    System.out.println("线程1");
                    
                }
            }).start();
             new Thread(new Runnable() {
                    
                    @Override
                    public void run() {
                        System.out.println("线程2");
                        
                    }
                }).start();
             ex.execute(new Runnable() {
                
                @Override
                public void run() {
                
                 synchronized (this) {
                     System.out.println("线程三");
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    notifyAll();
                }
                    
                }
            });
    }
    }
}

线程1
线程2
线程三
线程1
线程2
线程三

newFixedThreadPool

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

//线程池  防止频繁的创建线程  减少
public class Test3 {
    public static void main(String[] args) {
             //创建线程池
        Executor ec = Executors.newFixedThreadPool(3);//int  线程池中保留的个数
        ec.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1");
                
            }
        });
        ec.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2");
                
            }
        });
        
        }
}

newScheduledThreadPool

    package test;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.ScheduledExecutorService;  
    import java.util.concurrent.TimeUnit;  
    public class ThreadPoolExecutorTest {  
     public static void main(String[] args) {  
      ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
      scheduledThreadPool.schedule(new Runnable() {  
       public void run() {  
        System.out.println("delay 3 seconds");  
       }  
      }, 3, TimeUnit.SECONDS);  
     }  
    }  

结果延迟3秒执行.

newSingleThreadExecutor

    package test;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    public class ThreadPoolExecutorTest {  
     public static void main(String[] args) {  
      ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
      for (int i = 0; i < 10; i++) {  
       final int index = i;  
       singleThreadExecutor.execute(new Runnable() {  
        public void run() {  
         try {  
          System.out.println(index);  
          Thread.sleep(2000);  
         } catch (InterruptedException e) {  
          e.printStackTrace();  
         }  
        }  
       });  
      }  
     }  
    }  

结果一次输出,相当于顺序执行.

• corePoolSize 核心池的大小,基本大小,即在没有任务需要执行的时候线程池的大小
• maximunPoolSize 线程池最大线程数 表示在线程池中最多能创建多少个线程.线程中当前线程数目不会超过这个值.