java 多线程

1   Thread，Runnable来操作多线程

----------------------------------------------------------------------------------------------------------------------------------------------------------

2  CountDownLatch（闭锁）

　JDk1.5提供了一个非常有用的包，Concurrent包，这个包主要用来操作一些并发操作，提供一些并发类，可以方便在项目当中傻瓜式应用。

　　JDK1.5以前，使用并发操作，都是通过Thread，Runnable来操作多线程；但是在JDK1.5之后，提供了非常方便的线程池（ThreadExecutorPool），主要代码由大牛Doug Lea完成，其实是在jdk1.4时代，由于java语言内置对多线程编程的支持比较基础和有限，所以他写了这个，因为实在太过于优秀，所以被加入到jdk之中；

　　这次主要对CountDownLatch进行系统的讲解

　　使用场景：比如对于马拉松比赛，进行排名计算，参赛者的排名，肯定是跑完比赛之后，进行计算得出的，翻译成Java识别的预发，就是N个线程执行操作，主线程等到N个子线程执行完毕之后，在继续往下执行。

      代码示例

     

 1 public static void testCountDownLatch(){
 2         
 3         int threadCount = 10;
 4         
 5         final CountDownLatch latch = new CountDownLatch(threadCount);
 6         
 7         for(int i=0; i< threadCount; i++){
 8              
 9             new Thread(new Runnable() {
10                 
11                 @Override
12                 public void run() {
13 
14                     System.out.println("线程" + Thread.currentThread().getId() + "开始出发");
15 
16                     try {
17                         Thread.sleep(1000);
18                     } catch (InterruptedException e) {
19                         e.printStackTrace();
20                     }
21 
22                     System.out.println("线程" + Thread.currentThread().getId() + "已到达终点");
23 
24                     latch.countDown();
25                 }
26             }).start();
27         }
28         
29         try {
30             latch.await();
31         } catch (InterruptedException e) {
32             e.printStackTrace();
33         }
34 
35         System.out.println("10个线程已经执行完毕！开始计算排名");
36     }

　　执行结果：

线程10开始出发
线程13开始出发
线程12开始出发
线程11开始出发
线程14开始出发
线程15开始出发
线程16开始出发
线程17开始出发
线程18开始出发
线程19开始出发
线程14已到达终点
线程15已到达终点
线程13已到达终点
线程12已到达终点
线程10已到达终点
线程11已到达终点
线程16已到达终点
线程17已到达终点
线程18已到达终点
线程19已到达终点
10个线程已经执行完毕！开始计算排名

　　

　　源码分析：

      　　1、CountDownLatch:A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

　　　　大致意思：也就是说主线程在等待所有其它的子线程完成后再往下执行

　　　　

　　　　2、构造函数：CountDownLatch(int count)//初始化count数目的同步计数器，只有当同步计数器为0，主线程才会向下执行
　　　　　 主要方法：void await()//当前线程等待计数器为0 
      　　　　　　　　 boolean await(long timeout, TimeUnit unit)//与上面的方法不同，它加了一个时间限制。
     　　　　　　　　 void countDown()//计数器减1
      　　　　　　　　long getCount()//获取计数器的值

      　　3.它的内部有一个辅助的内部类：sync.

　　　　   它的实现如下：

　　　　　

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

/**       * Synchronization control For CountDownLatch.       * Uses AQS state to represent count.       */      private  static  final  class  Sync  extends  AbstractQueuedSynchronizer {          private  static  final  long  serialVersionUID = 4982264981922014374L;            Sync( int  count) {              setState(count);          }            int  getCount() {              return  getState();          }            protected  int  tryAcquireShared( int  acquires) {              return  (getState() ==  0 ) ?  1  : - 1 ;          }            protected  boolean  tryReleaseShared( int  releases) {              // Decrement count; signal when transition to zero              for  (;;) {                  int  c = getState();                  if  (c ==  0 )                      return  false ;                  int  nextc = c- 1 ;                  if  (compareAndSetState(c, nextc))                      return  nextc ==  0 ;              }          }      }

　　4.await()方法的实现
  　　sync.acquireSharedInterruptibly(1);
     -->if (tryAcquireShared(arg) < 0)//调用3中的tryAcquireShared()方法
            doAcquireSharedInterruptibly(arg);//加入到等待队列中

　　5.countDown（）方法的实现
  　　sync.releaseShared(1);
     --> if (tryReleaseShared(arg))//调用3中的tryReleaseShared（）方法
               doReleaseShared();//解锁

　　　　　　

参考文章：

           https://my.oschina.net/u/1185331/blog/502350

           http://blog.itpub.net/30024515/viewspace-1432825/

====================================================================================

3 ExecutorService extends Executor  

 ExecutorService executor = Executors.newFixedThreadPool(MAX_POOL_SIZE);
while (iterator.hasNext()) {
LBHostInfoVOMongo mongo = iterator.next();
executor.execute(new Runnable() {
@Override
public void run() {
try {
dao.addLBInfoMonitorResult(mongo, startTime, endTime, time_stamp);
} catch (Exception e) {
logger.error(UTrace.trace(e));
}
}
});
}
executor.shutdown();

    

　---------------------------------------

ExecutorService（线程池）可以被关闭来拒绝新任务。有两个不同的方法来关闭。 
shutdown方法 在关闭 ExecutorService 之前等待提交的任务执行完成。 
shutdownNow方法 会阻止开启新的任务并且尝试停止当前正在执行的线程，一旦调用该方法，线程池中将没有激活的任务，没有等待执行的任务，也没有新任务提交。 
没有任务执行的ExecutorService将会被回收。

方法submit扩展了Executor.execute(Runnable) 方法， 创建并返回一个 Future 结果，这个Future可以取消任务的执行或者等待完成得到返回值。 
方法invokeAny and invokeAll 可以执行一组任务，等待至少一个任务或者多个任务完成（ExecutorCompletionService扩展了这些方法的实现）。

===============================================================================

4  executor.submit（）

Future<GenericResponse> future = executor.submit(new Callable<GenericResponse>() {
@Override
public GenericResponse call() throws Exception {
return callbackSaveLog(req);
}
});　

/**
* 负载均衡创建
* @author jz
* @date 2017年9月6日 下午7:49:33
* @param request
* @param response void
*/
@RequestMapping(value = "create")
public void create(HttpServletRequest request, HttpServletResponse response) {
try {
CommonInstanceCreateDTO req = URequest.getObject(request, CommonInstanceCreateDTO.class);
logger.debug(UJson.toString(req));
Future<GenericResponse> future = executor.submit(new Callable<GenericResponse>() {
@Override
public GenericResponse call() throws Exception {
return loadBalanceCreateService.handleCreateArrow(req);
}
});
UResponse.json(future.get(), response);
} catch (Throwable e) {
logger.error(UTrace.trace(e));
UResponse.json(ISmartResponses.SYSTEM_ERROR, response);
}
}

 

<T> Future<T> submit(Callable<T> task);
 
 
1

提交一个带有返回值的任务（Callable），返回值为Future，表示了任务的执行完成结果，Future.get()方法返回成功执行后的结果。 
如果你想要阻塞当前线程知道执行完成返回结果，那么你可以这样做： 
result = exec.submit(aCallable).get();

<T> Future<T> submit(Runnable task, T result);
 
 
1

提交一个Runnable任务执行，返回一个Future做为任务task的代理，Future.get()方法在执行成功后可以返回结果。 
Runnable task 提交的任务 
T results 执行的结果

==================================================================================================

5