并发concurrent---2

背景：并发知识是一个程序员段位升级的体现，同样也是进入BAT的必经之路，有必要把并发知识重新梳理一遍。

并发concurrent:

使用ThreadLocal可以实现线程范围内共享变量，线程A写入的值和线程B获取到的结果一致；ReentrantReadWriteLock允许多个读线程或多个写线程同时进行，但不允许写线程和读线程同时进行；使用Callable可以得到线程执行的返回结果；Exchanger可以相互交换家线程执行的结果；这些使用方法大致都一样，JDk参考文档里面哪里不会点哪里，下面写个ThreadLocal实现线程范围内变量共享，里面还用到了一下饿汉模式：

执行结果如图中控制台打印，使用ThreadLocal保证了线程0和线程1读取到的值与写入的一致。

 import java.util.Random;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import lombok.Data;

 public class ThreadLocalTest {
     //ThreadLocal 实现线程范围内共享变量
     private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
     private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();
     public static void main(String[] args) {
         new ReentrantReadWriteLock();
         for(int i = 0; i<2; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     int data = new Random().nextInt();
                     System.out.println(Thread.currentThread().getName()
                             +" has put data: "+ data);
                     x.set(data);  // 存的时候与当前线程相关 取的时候也是与当前线程相关
                     //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象： 不用反复new对象来getter/setter
                     MyThreadScopeData.getThreadInstance().setName("name: "+data);
                     MyThreadScopeData.getThreadInstance().setAge(data);
                     new A().get();
                     new B().get();
                 }
             }).start();
         }
 }

     static class A{
         public void get() {
             int data = x.get();
             System.out.println("A from "+Thread.currentThread().getName()+" get data: "+data);
             //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象
             MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
             System.out.println("A from "+Thread.currentThread().getName()
                     +" getMyData: "+myData.getName() +","+myData.getAge());
         }
     }

     static class B{
         public void get() {
             int data = x.get();
             System.out.println("B from "+Thread.currentThread().getName()+" get data: "+data);
             //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象
             MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
             System.out.println("B from "+Thread.currentThread().getName()
                     +" getMyData: "+myData.getName() +","+myData.getAge());
         }
     }

     //设计自己线程范围内变量的共享，不需要创建对象，只需调用线程即可用到线程内的变量
     @Data
     static class MyThreadScopeData{
         //构造方法私有化，外部没发直接调用，但是可以调用里面的静态方法
         private MyThreadScopeData() { }
         public static /*synchronized*/ MyThreadScopeData getThreadInstance() {
             MyThreadScopeData instance = map.get();
             if (instance == null) {
                 //饿汉模式 ： 第一次来创建
                 instance = new MyThreadScopeData();
                 map.set(instance);
             }
             return instance;
         }
     //    private static MyThreadScopeData instance = null; // new MyThreadScopeData();
         private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
         private String name;
         private int age;
     }

 }

网上还有一个多线程面试很有趣的题目：子线程执行10次，主线程执行100次，接着子线程再执行10次，主线程继续再执行100次，往复循环50次；

 //Java多线程面试： 子线程执行10次，主线程执行100次，接着子线程再10次，主线程再执行100次，往复循环50次
 public class ThreadCommunication {
     public static void main(String[] args) {
      Business business = new Business();
     new Thread(
             new Runnable() {
         @Override
         public void run() {
             for (int i = 1; i <= 50; i++) {
                 business.sub(i);
             }
         }
     }).start();

     for (int i = 1; i <= 50; i++) {
         business.main(i);
     }
     }

     //把主线程和自线程执行的方法归结到一个类(共同算法的若干方法)，巧妙设计，好维护高聚合，健壮性；
     public static class Business{
         //子线程方法
         private boolean bShouldSub = true;
         public synchronized void sub(int i) {
             while(!bShouldSub) {
                 //用while比if更好，可以防止线程被伪唤醒
                 try {
                     this.wait(); // 如果不是子线程方法该执行的，则令其等待
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             for(int j = 1; j<= 10; j++) {
                 System.out.println("sub thread sequence of "+j + ",loop of "+ i);
             }
             bShouldSub = false;
             this.notify(); //唤醒主线程方法
         }        

     //主线程方法
     public synchronized void main(int i) {
         while(!bShouldSub) {
             try {
                 this.wait();  // 如果不是主线程方法该执行的，则令其等待
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         for(int j = 1; j<= 100; j++) {
             System.out.println("main thread sequence of "+j + ",loop of "+ i);
         }
         bShouldSub = true;
         this.notify();  // 唤醒子线程方法
     }
     }
 }

线程池：

1、固定线程数目的线程池newFixedThreadPool；

2、缓存线程数目的线程池newCachedThreadPool；

3、单一线程池newSingleThreadExecutor；

4、定时器线程池newScheduledThreadPool；

 package com.xinyan.springcloud.controller;

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;

 public class ThreadPoolTest {
     public static void main(String[] args) {
         //固定线程数目的线程池  3个
          ExecutorService threadPool = Executors.newFixedThreadPool(3);
         //缓存线程数目的线程池即动态变化  当任务过来了，线程池内部会自动增加线程，空闲后线程又被回收，线程数目不定
         //ExecutorService threadPool = Executors.newCachedThreadPool();
         //单一线程池
         //ExecutorService threadPool = Executors.newSingleThreadExecutor();
         //往线程池中放入10个任务：
         for(int i = 1; i<= 10; i++) {
             final int task = i; // task被final修饰不能变了，但是i 可以变
             threadPool.execute(new Runnable() {
                 @Override
                 public void run() {
                     for(int j =1; j<=10; j++) {
                         try {
                             Thread.sleep(200);
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                         //System.out.println(Thread.currentThread().getName()+" loop of "+ j +" task is "+ task);
                     }
                 }
             });
         }
         System.out.println("所有的10个任务已经全部提交。");   //任务都提交了，交由线程池去搞
         threadPool.shutdown();   //没有任务后关闭线程
           //threadPool.shutdownNow();    //还有任务没有给执行完毕就立即关闭线程

         //定时器线程池： 3个线程
         System.out.println("敌军还有5秒到达战场.");
         Executors.newScheduledThreadPool(3).schedule(new Runnable() {
             @Override
             public void run() {
                 System.out.println("敌军抵达战场，碾碎她们。");
             }
             //5秒后执行线程池内run方法
         }, 5, TimeUnit.SECONDS);
         //Executors.newScheduledThreadPool(3)scheduleAtFixedRate(command, initialDelay, period, unit)
         //scheduleAtFixedRate 定时循环执行线程池内方法
     }
 }