java-线程池与原子(Automic)

1.Executors类

    |-java.util.concurrent.Executors 它可以提供了多种功能的线程池
   静态方法：

            ExecutorService  newFixedThreadPool(int nThreads); //创建固定大小的线程池

            ExecutorService  newCachedThreadPool();//创建缓存线程池

            ExecutorService  newSingleThreadExecutor();//创建单一线程池

      ScheduledExecutorService  newScheduledThreadPool(int);//创建定时处理的线程池

2.ExecutorService

  成员方法:

     void shutdown();//对于执行完所有任务的线程会处于wait状态，所以最后需要
                                      Executors类的shutdown方法销毁执行完任务的线程

        void execute(Runnable command);//可以添加多个任务

        Future<T> submit(Callable<T> task);//在task里会调用call方法，将结果返回给future

3.ScheduledExecutorService

     schedule(Runnable command, long delay, TimeUnit unit);//创建并执行在给定延迟后启用的一次性操作

            线程池启动定时器
            调用ScheduledExecutorService的schedule方法，返回的ScheduleFuture对象可以取消任务。
            支持间隔重复任务的定时方式，不直接支持绝对定时方式，需要转换成相对时间方式。

4.CompletionService<V>

   所有已知实现类：ExecutorCompletionService   它是ExecutorService里submit方法的加强版，可以submit多个Callable<T> task，使用者take会按照完成这些任务的顺序处理它们的结果(get方法返回结果)。

      成员方法:

Future<V> take();//获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。

Future<V> submit(Callable<V> task);//提交要执行的值返回任务，并返回表示挂起的任务结果的 Future。

 

//ExecutorService类下的<T> Future<T> submit(Callable<T> task) 方法使用
         ExecutorService pool= Executors.newSingleThreadExecutor();
         Future<String> future=pool.submit(new Callable<String>() {

            @Override
            public String  call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(3000);
                 
                return "哈哈哈";
            }
        });
      System.out.println("等待结果");
      System.out.println("结果:"+future.get());
      //ExecutorCompletionService类演示
      CompletionService<Integer> service=new ExecutorCompletionService<Integer>(Executors.newFixedThreadPool(3));
      //submit 10个task
      for(int i=0;i<10;i++)
      {
          final int t=i+1;
          service.submit(new Callable<Integer>() {
            
            @Override
            public Integer call() throws Exception {
                 Thread.sleep(new Random().nextInt(5)*1000);
                return t;
            }
        });
      }
      //按先后顺序取出结果
      for(int j=0;j<10;j++)
      {
          System.out.println(service.take().get());
      }

 

     

//线程池的演示：Executors类下(静态方法)提供了多种功能的线程池
      /*  注意：可以添加任意个任务进去.(ExecutorService类下的void execute(Runnable command)方法)
       *  创建固定大小的线程池:Executors.newFixedThreadPool(3);3为自动启动3个线程执行任务
                      创建缓存线程池:Executors.newCachedThreadPool();//系统会根据你添加多少任务智能分配多少个线程帮你执行
                      创建单一线程池:Executors.newSingleThreadExecutor();//系统会保证始终一个线程帮你执行任务，如果该线程死了，系统会创建出另一个线程代替。

创建定时处理的线程池：Executors.newScheduledThreadPool(3).schedule()方法     
                     注意:对于执行完所有任务的线程会处于wait状态，所以最后需要
               Executors类的shutdown方法销毁执行完任务的线程。      
       * */  
        ExecutorService pool=Executors.newFixedThreadPool(3);
        Executors.newCachedThreadPool();
        Executors.newSingleThreadExecutor();
        //添加任务
        for(int i=0;i<5;i++)
        {
            final int task =i+1;
            pool.execute(new Runnable() {
                
                @Override
                public void run() {
                    for(int j=0;j<10;j++)
                    System.out.println(Thread.currentThread().getName()+"执行第"+task+"个任务："+(j+1));
                }
            });
         }
        System.out.println("shutdown");
        pool.shutdown();

 

 5.java.util.concurrent.atomic下

  有很多对基本数据的原子(同步)操作，甚至是类中的成员变量