Java之J.U.C——tools

转载:https://blog.csdn.net/xieyuooo/article/details/8572543

J.U.C体系的主要大板块包含内容,如下图所示:



注意这个里面每个部分都包含很多的类和处理器,而且是相互包含,相互引用的,相互实现的。

说到J UC其实就是说java的多线程等和锁,前面说过一些状态转换,中断等,我们今天来用它的tools来实现一些有些小意思的东西,讲到其他内容的时候,再来想想这写tools是怎么实现的。

tools是本文说要讲到的重点,而tools主要包含哪些东西呢:


Tools也包含了5个部分的知识:ExecutorsSemaphor、Exchanger、CyclicBarrier、CountDownLatch,其实也就是五个工具类,这5个工具类有神马用途呢,就是我们接下来要将的内容了。


Executors:

其实它主要用来创建线程池,代理了线程池的创建,使得你的创建入口参数变得简单,通过方法名便知道了你要创建的线程池是什么样一个线程池,功能大概是什么样的,其实线程池内部都是统一的方法来实现,通过构造方法重载,使得实现不同的功能,但是往往这种方式很多时候不知道具体入口参数的改变有什么意思,除非读了源码才知道,此时builder模式的方式来完成,builder什么样的东西它告诉你就可以。

常见的方法有(都是静态方法):

1、创建一个指定大小的线程池,如果超过大小,放入blocken队列中,默认是LinkedBlockingQueue,默认的ThreadFactory为:Executors.defaultThreadFactory(),是一个Executors的一个内部类。

Executors.newFixedThreadPool(int) 

内部实现是:

[java] view plain copy
  1. public static ExecutorService newFixedThreadPool(int nThreads) {  
  2.     return new ThreadPoolExecutor(nThreads, nThreads,  
  3.                                   0L, TimeUnit.MILLISECONDS,  
  4.                                   new LinkedBlockingQueue<Runnable>());  
  5. }  


2、创建一个指定大小的线程池,如果超过大小,放入blocken队列中,默认是LinkedBlockingQueue,自己指定ThreadFactory,自己写的ThreadFactory,必须implements ThreadFactory,实现方法:newThread(Runnable)

Executors.newFixedThreadPool(int,ThreadFactory) 
内部实现是:

[java] view plain copy
  1. public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {  
  2.     return new ThreadPoolExecutor(nThreads, nThreads,  
  3.                                   0L, TimeUnit.MILLISECONDS,  
  4.                                   new LinkedBlockingQueue<Runnable>(),  
  5.                                   threadFactory);  
  6. }  

3、创建线程池长度为1的,也就是只有一个长度的线程池,多余的必须等待,它和调用Executors.newFixedThreadPool(1)得到的结果一样:

 Executors.newSingleThreadExecutor() 

内部实现是:

[java] view plain copy
  1. public static ExecutorService newSingleThreadExecutor() {  
  2.     return new FinalizableDelegatedExecutorService  
  3.         (new ThreadPoolExecutor(11,  
  4.                                 0L, TimeUnit.MILLISECONDS,  
  5.                                 new LinkedBlockingQueue<Runnable>()));  
  6. }  
是不是蛮简单的,就是在变参数,你自己也可以new的。

4、和方法3类似,可以自定义ThreadFactory,这里就不多说了!

5、创建可以进行缓存的线程池,默认缓存60s,数据会放在一个SynchronousQueue上,而不会进入blocken队列中,也就是只要有线程进来就直接进入调度,这个不推荐使用,因为容易出问题,除非用来模拟一些并发的测试:

Executors.newCachedThreadPool();

内部实现为:

[java] view plain copy
  1. public static ExecutorService newCachedThreadPool() {  
  2.     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
  3.                                   60L, TimeUnit.SECONDS,  
  4.                                   new SynchronousQueue<Runnable>());  
  5. }  
6、和方法5类似,增加自定义ThreadFactory

7、添加一个Schedule的调度器的线程池,默认只有一个调度:

Executors.newSingleThreadScheduledExecutor();

内部实现为(这里可以看到不是用ThreadPoolExector了,schedule换了一个类,内部实现通过ScheduledThreadPoolExecutor类里面的内部类ScheduledFutureTask来实现的,这个内部类是private,默认是引用不到的哦):

[java] view plain copy
  1. public static ScheduledExecutorService newSingleThreadScheduledExecutor() {  
  2.     return new DelegatedScheduledExecutorService  
  3.         (new ScheduledThreadPoolExecutor(1));  
  4. }  
8、和7一样,增加自己定义的ThreadFactory

9、添加一个schedule的线程池调度器,和newFixedThreadPool有点类似:

Executors.newScheduledThreadPool();
内部代码为:

[java] view plain copy
  1. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  
  2.     return new ScheduledThreadPoolExecutor(corePoolSize);  
  3. }  

其实内部Exectors里面还有一些其他的方法,我们就不多说明了,另外通过这里,大家先可以了解一个大概,知道Exectors其实是一个工具类,提供一系列的静态方法,来完成对对应线程池的形象化创建,所以不用觉得很神奇,神奇的是内部是如何实现的,本文我们不阐述文章中各种线程池的实现,只是大概上有个认识,等到我们专门将Exector系列的时候,我们会详细描述这些细节。

OK,我们继续下一个话题:

Semaphor,这个鸟东西是敢毛吃的呢?

答:通过名字就看出来了,是信号量。

信号量可以干什么呢?

答:根据一些阀值做访问控制。

OK,我们这里模拟一个当多个线程并发一段代码的时候,如何控制其访问速度:

[java] view plain copy
  1. import java.util.Random;  
  2. import java.util.concurrent.Semaphore;  
  3.   
  4.   
  5.   public class SemaphoreTest {  
  6.       private final static Semaphore MAX_SEMA_PHORE = new Semaphore(10);  
  7.       public static void main(String []args) {  
  8.            for(int i = 0 ; i < 100 ; i++) {  
  9.                 final int num = i;  
  10.                 final Random radom = new Random();  
  11.                 new Thread() {  
  12.                      public void run() {  
  13.                          boolean acquired = false;  
  14.                          try {  
  15.                               MAX_SEMA_PHORE.acquire();  
  16.                               acquired = true;  
  17.                               System.out.println("我是线程:" + num + " 我获得了使用权!" + DateTimeUtil.getDateTime());  
  18.                               long time = 1000 * Math.max(1, Math.abs(radom.nextInt() % 10));  
  19.                               Thread.sleep(time);  
  20.                               System.out.println("我是线程:" + num + " 我执行完了!" + DateTimeUtil.getDateTime());  
  21.                          }catch(Exception e) {  
  22.                               e.printStackTrace();  
  23.                          }finally {  
  24.                               if(acquired) {  
  25.                                  MAX_SEMA_PHORE.release();  
  26.                               }  
  27.                          }  
  28.                       }  
  29.                 }.start();  
  30.            }  
  31.       }  
  32.   }  


这里是简单模拟并发100个线程去访问一段程序,此时要控制最多同时运行的是10个,用到了这个信号量,运行程序用了一个线程睡眠一个随机的时间来代替,你可以看到后面有线程说自己释放了,就有线程获得了,没释放是获取不到的,内部实现方面,我们暂时不管,暂时知道这样用就OK。


接下来:

Exchanger十个神马鬼东西呢?

答:线程之间交互数据,且在并发时候使用,两两交换,交换中不会因为线程多而混乱,发送出去没接收到会一直等,由交互器完成交互过程。

啥时候用,没想到案例?

答:的确很少用,而且案例很少,不过的确有这种案例,Exchanger

[java] view plain copy
  1. import java.util.concurrent.Exchanger;  
  2.   
  3. public class ExchangerTest {  
  4.       
  5.     public static void main(String []args) {  
  6.         final Exchanger <Integer>exchanger = new Exchanger<Integer>();  
  7.         for(int i = 0 ; i < 10 ; i++) {  
  8.             final Integer num = i;  
  9.             new Thread() {  
  10.                 public void run() {  
  11.                     System.out.println("我是线程:Thread_" + this.getName() + "我的数据是:" + num);  
  12.                     try {  
  13.                         Integer exchangeNum = exchanger.exchange(num);  
  14.                         Thread.sleep(1000);  
  15.                         System.out.println("我是线程:Thread_" + this.getName() + "我原先的数据为:" + num + " , 交换后的数据为:" + exchangeNum);  
  16.                     } catch (InterruptedException e) {  
  17.                         e.printStackTrace();  
  18.                     }  
  19.                 }  
  20.             }.start();  
  21.         }  
  22.     }  
  23. }  


这里运行你可以看到,如果某个线程和另一个线程传送了数据,它接受到的数据必然是另一个线程传递给他的,中间步骤由Exchanger去控制,其实你可以说,我自己随机取选择,不过中间的算法逻辑就要复杂一些了。


接下来:

CyclicBarrier,关卡模式,搞啥玩意的呢?

答:当你在很多环节需要卡住,要多个线程同时在这里都达到后,再向下走,很有用途。

能否举个例子,有点抽象?

答:团队出去旅行,大家一起先达到酒店住宿,然后一起达到游乐的地方游玩,然后一起坐车回家,每次需要点名后确认相关人员均达到,然后LZ一声令下,触发,大伙就疯子般的出发了。

下面的例子也是以旅游的方式来呈现给大家:

[java] view plain copy
  1. import java.util.concurrent.BrokenBarrierException;  
  2. import java.util.concurrent.CyclicBarrier;  
  3.   
  4. public class BarrierTest {  
  5.       
  6.     private static final int THREAD_COUNT = 10;  
  7.       
  8.     private final static CyclicBarrier CYCLIC_BARRIER = new CyclicBarrier(THREAD_COUNT  ,  
  9.         new Runnable() {  
  10.             public void run() {  
  11.                 System.out.println("======>我是导游,本次点名结束,准备走下一个环节!");  
  12.             }  
  13.         }  
  14.     );  
  15.       
  16.     public static void main(String []args)   
  17.             throws InterruptedException, BrokenBarrierException {  
  18.         for(int i = 0 ; i < 10 ; i++) {  
  19.             new Thread(String.valueOf(i)) {  
  20.                 public void run() {  
  21.                     try {  
  22.                         System.out.println("我是线程:" + this.getName() + " 我们达到旅游地点!");  
  23.                         CYCLIC_BARRIER.await();  
  24.                         System.out.println("我是线程:" + this.getName() + " 我开始骑车!");  
  25.                         CYCLIC_BARRIER.await();  
  26.                         System.out.println("我是线程:" + this.getName() + " 我们开始爬山!");  
  27.                         CYCLIC_BARRIER.await();  
  28.                         System.out.println("我是线程:" + this.getName() + " 我们回宾馆休息!");  
  29.                         CYCLIC_BARRIER.await();  
  30.                         System.out.println("我是线程:" + this.getName() + " 我们开始乘车回家!");  
  31.                         CYCLIC_BARRIER.await();  
  32.                         System.out.println("我是线程:" + this.getName() + " 我们到家了!");  
  33.                     } catch (InterruptedException e) {  
  34.                         e.printStackTrace();  
  35.                     } catch (BrokenBarrierException e) {  
  36.                         e.printStackTrace();  
  37.                     }  
  38.                 }  
  39.             }.start();  
  40.         }  
  41.     }  
  42. }  

测试结果中可以发现,大家一起走到某个步骤后,导游说:“我是导游,本次点名结束,准备走下一个环节!”,然后才会进入下一个步骤,OK,这个有点意思吧,其实赛马也是这个道理,只是赛马通常只有一个步骤,所以我们还有一个方式是:

CountDownLatch的方式来完成赛马操作,CountDownLatch是用计数器来做的,所以它不可以被复用,如果要多次使用,就要从新new一个出来才可以。我们下面的代码中,用两组赛马,每组5个参与者来,做一个简单测试:

[java] view plain copy
  1. import java.util.concurrent.CountDownLatch;  
  2.   
  3. public class CountDownLatchTest {  
  4.       
  5.     private final static int GROUP_SIZE = 5;  
  6.       
  7.     public static void main(String []args) {  
  8.         processOneGroup("分组1");  
  9.         processOneGroup("分组2");  
  10.     }  
  11.       
  12.     private static void processOneGroup(final String groupName) {  
  13.         final CountDownLatch start_count_down = new CountDownLatch(1);  
  14.         final CountDownLatch end_count_down = new CountDownLatch(GROUP_SIZE);  
  15.         System.out.println("==========================>\n分组:" + groupName + "比赛开始:");  
  16.         for(int i = 0 ; i < GROUP_SIZE ; i++) {  
  17.             new Thread(String.valueOf(i)) {  
  18.                 public void run() {  
  19.                     System.out.println("我是线程组:【" + groupName + "】,第:" + this.getName() + " 号线程,我已经准备就绪!");  
  20.                     try {  
  21.                         start_count_down.await();//等待开始指令发出即:start_count_down.countDown();  
  22.                     } catch (InterruptedException e) {  
  23.                         e.printStackTrace();  
  24.                     }  
  25.                     System.out.println("我是线程组:【" + groupName + "】,第:" + this.getName() + " 号线程,我已执行完成!");  
  26.                     end_count_down.countDown();  
  27.                 }  
  28.             }.start();  
  29.         }  
  30.         try {  
  31.             Thread.sleep(1000);  
  32.         } catch (InterruptedException e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("各就各位,预备!");  
  36.         start_count_down.countDown();//开始赛跑  
  37.         try {  
  38.             end_count_down.await();//等待多个赛跑者逐个结束  
  39.         } catch (InterruptedException e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.         System.out.println("分组:" + groupName + "比赛结束!");  
  43.     }  
  44. }  


有点意思哈,如果你自己用多线程实现是不是有点麻烦,不过你可以用Thread的join方法来实现,也就是线程的发生join的时候,当前线程(一般是主线程)要等到对应线程执行完run方法后才会进入下一步,为了模拟下,我们也来玩玩:

[java] view plain copy
  1. public class ThreadJoinTest {  
  2.       
  3.     private final static int GROUP_SIZE = 5;  
  4.   
  5.     public static void main(String []args) throws InterruptedException {  
  6.         Thread []threadGroup1 = new Thread[5];  
  7.         Thread []threadGroup2 = new Thread[5];  
  8.         for(int i = 0 ; i < GROUP_SIZE ; i++) {  
  9.             final int num = i;  
  10.             threadGroup1[i] = new Thread() {  
  11.                 public void run() {  
  12.                     int j = 0;  
  13.                     while(j++ < 10) {  
  14.                         System.out.println("我是1号组线程:" + num + " 这个是我第:" + j + " 次运行!");  
  15.                     }  
  16.                 }  
  17.             };  
  18.             threadGroup2[i] = new Thread() {  
  19.                 public void run() {  
  20.                     int j = 0;  
  21.                     while(j++ < 10) {  
  22.                         System.out.println("我是2号组线程:" + num + " 这个是我第:" + j + " 次运行!");  
  23.                     }  
  24.                 }  
  25.             };  
  26.             threadGroup1[i].start();  
  27.         }  
  28.         for(int i = 0 ; i < GROUP_SIZE ; i++) {  
  29.             threadGroup1[i].join();  
  30.         }  
  31.         System.out.println("-==================>线程组1执行完了,该轮到俺了!");  
  32.         for(int i = 0 ; i < GROUP_SIZE ; i++) {  
  33.             threadGroup2[i].start();  
  34.         }  
  35.         for(int i = 0 ; i < GROUP_SIZE ; i++) {  
  36.             threadGroup2[i].join();  
  37.         }  
  38.         System.out.println("全部结束啦!哈哈,回家喝稀饭!");  
  39.     }  
  40. }  


代码是不是繁杂了不少,呵呵,我们再看看上面的信号量,如果不用工具,自己写会咋写,我们模拟CAS锁,使用Atomic配合完成咋来做呢。也来玩玩,呵呵:

[java] view plain copy
  1. import java.util.concurrent.atomic.AtomicInteger;  
  2.   
  3. public class ThreadWaitNotify {  
  4.       
  5.     private final static int THREAD_COUNT = 100;  
  6.       
  7.     private final static int QUERY_MAX_LENGTH = 2;  
  8.       
  9.     private final static AtomicInteger NOW_CALL_COUNT = new AtomicInteger(0);  
  10.   
  11.     public static void main(String []args) throws InterruptedException {  
  12.         Thread []threads = new Thread[THREAD_COUNT];  
  13.         for(int i = 0 ; i < THREAD_COUNT ; i++) {  
  14.             threads[i] = new Thread(String.valueOf(i)) {  
  15.                 synchronized public void run() {  
  16.                     int nowValue = NOW_CALL_COUNT.get();  
  17.                     while(true) {  
  18.                         if(nowValue < QUERY_MAX_LENGTH && NOW_CALL_COUNT.compareAndSet(nowValue, nowValue + 1)) {  
  19.                             break;//获取到了  
  20.                         }  
  21.                         try {  
  22.                             this.wait(1000);  
  23.                         } catch (InterruptedException e) {  
  24.                             e.printStackTrace();  
  25.                         }  
  26.                         nowValue = NOW_CALL_COUNT.get();//获取一个数据,用于对比  
  27.                     }  
  28.                     System.out.println(this.getName() + "======我开始做操作了!");  
  29.                     try {  
  30.                         Thread.sleep(1000);  
  31.                     } catch (InterruptedException e) {  
  32.                         e.printStackTrace();  
  33.                     }  
  34.                     System.out.println(this.getName() + "======操作结束了!");  
  35.                     NOW_CALL_COUNT.getAndDecrement();  
  36.                     this.notify();  
  37.                 }  
  38.             };  
  39.         }  
  40.         for(int i = 0 ; i < THREAD_COUNT ; i++) {  
  41.             threads[i].start();  
  42.         }  
  43.     }  
  44. }  

还是有点意思哈,这样写就是大部分人对while循环那部分会写晕掉,主要是要不断去判定和尝试,wait()默认是长期等待,但是我们不想让他长期等待,就等1s然后再尝试,其实例子还可以改成wait一个随机的时间范围,这样模拟的效果会更加好一些;另外实际的代码中,如果获取到锁后,notify方法应当放在finally中,才能保证他肯定会执行notify这个方法。
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页