并发concurrent---2

Posted 2021-02-04 taojietaoge

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

 

并发concurrent:

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

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

 1 import java.util.Random;
 2 import java.util.concurrent.locks.ReentrantReadWriteLock;
 3 import lombok.Data;
 4 
 5 public class ThreadLocalTest {
 6     //ThreadLocal 实现线程范围内共享变量
 7     private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
 8     private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();
 9     public static void main(String[] args) {
10         new ReentrantReadWriteLock();
11         for(int i = 0; i<2; i++) {
12             new Thread(new Runnable() {
13                 @Override
14                 public void run() {
15                     int data = new Random().nextInt();
16                     System.out.println(Thread.currentThread().getName()
17                             +" has put data: "+ data);
18                     x.set(data);  // 存的时候与当前线程相关 取的时候也是与当前线程相关
19                     //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象： 不用反复new对象来getter/setter
20                     MyThreadScopeData.getThreadInstance().setName("name: "+data);
21                     MyThreadScopeData.getThreadInstance().setAge(data);
22                     new A().get();
23                     new B().get();
24                 }
25             }).start();
26         }
27 }
28     
29     static class A{
30         public void get() {
31             int data = x.get();
32             System.out.println("A from "+Thread.currentThread().getName()+" get data: "+data);
33             //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象
34             MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
35             System.out.println("A from "+Thread.currentThread().getName()
36                     +" getMyData: "+myData.getName() +","+myData.getAge());
37         }
38     }
39     
40     static class B{
41         public void get() {
42             int data = x.get();
43             System.out.println("B from "+Thread.currentThread().getName()+" get data: "+data);
44             //MyThreadScopeData.getInstance()拿到与本线程实例相关的对象
45             MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
46             System.out.println("B from "+Thread.currentThread().getName()
47                     +" getMyData: "+myData.getName() +","+myData.getAge());
48         }
49     }
50     
51     //设计自己线程范围内变量的共享，不需要创建对象，只需调用线程即可用到线程内的变量
52     @Data
53     static class MyThreadScopeData{
54         //构造方法私有化，外部没发直接调用，但是可以调用里面的静态方法
55         private MyThreadScopeData() { }
56         public static /*synchronized*/ MyThreadScopeData getThreadInstance() {
57             MyThreadScopeData instance = map.get();
58             if (instance == null) {
59                 //饿汉模式 ： 第一次来创建
60                 instance = new MyThreadScopeData();
61                 map.set(instance);
62             }
63             return instance;
64         }
65     //    private static MyThreadScopeData instance = null; // new MyThreadScopeData();
66         private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
67         private String name;
68         private int age;
69     }
70 
71 }

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

 1 //Java多线程面试： 子线程执行10次，主线程执行100次，接着子线程再10次，主线程再执行100次，往复循环50次
 2 public class ThreadCommunication {
 3     public static void main(String[] args) {
 4      Business business = new Business();
 5     new Thread(
 6             new Runnable() {
 7         @Override
 8         public void run() {
 9             for (int i = 1; i <= 50; i++) {
10                 business.sub(i);
11             }
12         }
13     }).start();
14     
15     for (int i = 1; i <= 50; i++) {
16         business.main(i);
17     }
18     }
19     
20     //把主线程和自线程执行的方法归结到一个类(共同算法的若干方法)，巧妙设计，好维护高聚合，健壮性；
21     public static class Business{
22         //子线程方法
23         private boolean bShouldSub = true;
24         public synchronized void sub(int i) {
25             while(!bShouldSub) {
26                 //用while比if更好，可以防止线程被伪唤醒
27                 try {
28                     this.wait(); // 如果不是子线程方法该执行的，则令其等待
29                 } catch (InterruptedException e) {
30                     e.printStackTrace();
31                 }
32             }
33             for(int j = 1; j<= 10; j++) {
34                 System.out.println("sub thread sequence of "+j + ",loop of "+ i);
35             }
36             bShouldSub = false;
37             this.notify(); //唤醒主线程方法
38         }        
39     
40     //主线程方法
41     public synchronized void main(int i) {
42         while(!bShouldSub) {
43             try {
44                 this.wait();  // 如果不是主线程方法该执行的，则令其等待
45             } catch (InterruptedException e) {
46                 e.printStackTrace();
47             }
48         }
49         for(int j = 1; j<= 100; j++) {
50             System.out.println("main thread sequence of "+j + ",loop of "+ i);
51         }
52         bShouldSub = true;
53         this.notify();  // 唤醒子线程方法
54     }
55     }
56 }

线程池：

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

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

3、单一线程池newSingleThreadExecutor；

4、定时器线程池newScheduledThreadPool；

 1 package com.xinyan.springcloud.controller;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 import java.util.concurrent.TimeUnit;
 6 
 7 public class ThreadPoolTest {
 8     public static void main(String[] args) {
 9         //固定线程数目的线程池  3个
10          ExecutorService threadPool = Executors.newFixedThreadPool(3);
11         //缓存线程数目的线程池即动态变化  当任务过来了，线程池内部会自动增加线程，空闲后线程又被回收，线程数目不定
12         //ExecutorService threadPool = Executors.newCachedThreadPool();
13         //单一线程池
14         //ExecutorService threadPool = Executors.newSingleThreadExecutor(); 
15         //往线程池中放入10个任务：
16         for(int i = 1; i<= 10; i++) {
17             final int task = i; // task被final修饰不能变了，但是i 可以变
18             threadPool.execute(new Runnable() {
19                 @Override
20                 public void run() {
21                     for(int j =1; j<=10; j++) {
22                         try {
23                             Thread.sleep(200);
24                         } catch (InterruptedException e) {
25                             e.printStackTrace();
26                         }
27                         //System.out.println(Thread.currentThread().getName()+" loop of "+ j +" task is "+ task);
28                     }
29                 }
30             });
31         }
32         System.out.println("所有的10个任务已经全部提交。");   //任务都提交了，交由线程池去搞
33         threadPool.shutdown();   //没有任务后关闭线程
34           //threadPool.shutdownNow();    //还有任务没有给执行完毕就立即关闭线程
35         
36         //定时器线程池： 3个线程  
37         System.out.println("敌军还有5秒到达战场.");
38         Executors.newScheduledThreadPool(3).schedule(new Runnable() {
39             @Override
40             public void run() {
41                 System.out.println("敌军抵达战场，碾碎她们。");
42             }
43             //5秒后执行线程池内run方法
44         }, 5, TimeUnit.SECONDS);
45         //Executors.newScheduledThreadPool(3)scheduleAtFixedRate(command, initialDelay, period, unit)
46         //scheduleAtFixedRate 定时循环执行线程池内方法
47     }
48 }