代码练习

Dear 丶 2023-02-28 04:18 42阅读 0赞

## 一、练习代码案例 ##

package com.citydo.faceadd.asyncandsynchro;
    
    import lombok.extern.slf4j.Slf4j;
    import lombok.var;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.EnableAsync;
    
    import java.util.*;
    import java.util.concurrent.*;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Slf4j
    @EnableAsync
    public class AsyncAndSynchro{ 
    
        @Autowired
        private AsyncService asyncService;
    
    
        /** * 同步转异步: * @Async */
        @Async
        public void AsyncTest(){ 
    
        }
    
        /** * 同步转异步: * CompletableFutureTask */
         static void CompletableFutureTask(){ 
             ExecutorService executorService = Executors.newFixedThreadPool(3);
             CompletableFuture a = CompletableFuture.supplyAsync(() -> { 
                 log.info("线程1开始");
                 try { 
                     TimeUnit.MILLISECONDS.sleep(100);
                 }catch (Exception e){ 
                     log.error("延时失败：{}",e);
                 }
                 log.info("线程1结束");
             return "1";
             },executorService);
             CompletableFuture b = CompletableFuture.supplyAsync(() -> { 
                 log.info("线程2开始");
                 try { 
                     TimeUnit.MILLISECONDS.sleep(100);
                 }catch (Exception e){ 
                     log.error("延时失败：{}",e);
                 }
                 log.info("线程2结束");
                 return "2";
             },executorService);
             CompletableFuture c = a.thenCombineAsync(b,(s1,s2) -> { 
                 log.info("组合线程");
                 return s1.toString().concat(s2.toString());
             },executorService);
             Object result = null;
             try { 
                 result = c.get();
             } catch (Exception e) { 
                 log.info("获取数据失败{}",e);
             }
             log.info("返回值：{}",result);
         }
    
        /** * 同步转异步: * 异步接口 */
        void asyncService(){ 
             asyncService.asyncInvoke(() -> { 
                 try { 
                     Thread.sleep(1000);
                     log.info("异步方法执行");
                 } catch (InterruptedException e) { 
                     log.error("延时失败：{}",e);
                 }
             });
          }
    
    
        /** * 异步转同步: * 使用wait和notify方法 */
        static class WaitNotify extends AsycCallBack{ 
            private final Object lock = new Object();
            @Override
            public void callback(long response) { 
               log.info("使用wait和notify方法：结果");
               log.info("回调值：{}",response);
               log.info("调用结果");
               synchronized (lock){ 
                   lock.notifyAll();
               }
            }
    
            public static void main(String[] args) { 
                WaitNotify waitNotify = new WaitNotify();
                waitNotify.call();
                synchronized (waitNotify.lock){ 
                    try { 
                        waitNotify.lock.wait();
                    }catch (Exception e){ 
                        log.info("等待失败：{}", e);
                    }
                }
                log.info("主线程中");
            }
        }
    
        /** * 异步转同步: * 使用条件锁 */
       static class ConditionalLock extends AsycCallBack{ 
    
            private final Lock  lock = new ReentrantLock();
            private final Condition condition = lock.newCondition();
            @Override
            public void callback(long response) { 
                log.info("使用条件锁：结果");
                log.info("回调值：{}",response);
                log.info("调用结果");
                lock.lock();
                try { 
                    condition.signal();
                }finally { 
                    lock.unlock();
                }
            }
    
            public static void main(String[] args) { 
                ConditionalLock conditionalLock = new ConditionalLock();
                conditionalLock.call();
                conditionalLock.lock.lock();
                try { 
                    conditionalLock.lock.wait();
                }catch (Exception e){ 
                    log.info("等待失败：{}", e);
                }finally { 
                    conditionalLock.lock.unlock();
                }
                log.info("主线程中");
            }
        }
    
        /** * 参考：https://www.jianshu.com/p/b7035543f54a * 异步转同步: * FutureTask 或者 Future * Callable + FutureTask + ExecutorService * Callable + FutureTask + ExecutorService */
        static class FutureTask { 
            private AsyncCall asyncCall = new AsyncCall();
            public Future<Long> call(){ 
                Future<Long> future = asyncCall.futureCall();
                asyncCall.shutdown();
                return future;
            }
            public static void main(String[] args) { 
                FutureTask futureTask = new FutureTask();
                log.info("调用");
                Future<Long> call = futureTask.call();
                log.info("调用结果");
                while (!call.isDone() && !call.isCancelled()) { 
                    log.info("进入循环中");
                }
                try { 
                    System.out.println(call.get());
                }catch (Exception e){ 
                    log.info("等待失败：{}", e);
                }
                log.info("主线程中");
            }
        }
    
    
        /** * 异步转同步: * 使用CountDownLatch */
        static class CountDownLatchTask extends AsycCallBack{ 
            private final CountDownLatch countDownLatch = new CountDownLatch(1);
            @Override
            public void callback(long response) { 
                log.info("使用条件锁：结果");
                log.info("回调值：{}",response);
                log.info("调用结果");
                countDownLatch.countDown();
            }
            public static void main(String[] args) { 
                CountDownLatchTask countDownLatchTask = new CountDownLatchTask();
                countDownLatchTask.call();
                try { 
                    countDownLatchTask.countDownLatch.await();
                }catch (Exception e){ 
                    log.info("等待失败：{}", e);
                }
                log.info("主线程中");
            }
        }
    
        /** * 异步转同步: * 使用CyclicBarrier */
        static class CyclicBarrierTask extends AsycCallBack{ 
            private CyclicBarrier cyclicBarrier = new CyclicBarrier(1);
            @Override
            public void callback(long response) { 
                log.info("使用条件锁：结果");
                log.info("回调值：{}",response);
                log.info("调用结果");
                try { 
                    cyclicBarrier.await();
                }catch (Exception e){ 
                    log.info("等待失败：{}", e);
                }
            }
            public static void main(String[] args) { 
                CyclicBarrierTask cyclicBarrierTask = new CyclicBarrierTask();
                cyclicBarrierTask.call();
                try { 
                    cyclicBarrierTask.cyclicBarrier.await();
                }catch (Exception e){ 
                    log.info("等待失败：{}", e);
                }
                log.info("主线程中");
            }
        }
    
        /** * 异步转同步: * rxjava */
        static class Rxjava{ 
    
    
        }
    
    
        /** * ifElse优化 * 1.简单if-else方式 */
        private void ifElseTest1(int input){ 
            //正常情况
            if(input>5){ 
            }else{ 
            }
            //优化后
            if(input>5){ 
                return;
            }
            //执行下面方法
        }
    
    
        /** * ifElse优化 * 2.价值匹配方式 */
        private String ifElseTest2(int input){ 
            //正常情况
            String gender = null;
            if(input == 0){ 
                gender = "0";
            }else if(input == 1){ 
                gender = "1";
            }else { 
                gender = "2";
            }
            //return gender;
            //优化后
            if(input < 0) { 
                throw new RuntimeException();
            }
            if(input > 1) { 
                throw new RuntimeException();
            }
            return input == 0 ? "0" : "1";
        }
    
        /** * ifElse优化 * 3.将If-Else转换为字典 */
        private void ifElseTest3(String input){ 
            //正常情况
            if("1".equals(input)){ 
    
            }else if("2".equals(input)){ 
    
            }else { 
    
            }
            //优化后
            var op = new HashMap<String, String>();
            if(op.containsKey("1")){ 
    
            }
            if(op.containsKey("2")){ 
    
            }
            Dictionary geek = new Hashtable();
        }
    
        /** * ifElse优化 * 3.将If-Else转换为MAP方式 */
        static class  MapIfElse{ 
            //组装数据
            private static Map<String, String> map = new HashMap<String, String>(){ 
                private static final long serialVersionUID = 1L;
                { 
                    put("1", "method1");
                    put("2", "method2");
                }
            };
    
            //调用传类型参数
            public void doBusiness(String type){ 
                this.callRemoteProduce(map.get(type));
            }
    
            //增加方法判断
            private void callRemoteProduce(String method){ 
                System.out.println(method);
            }
    
            public static void main(String[] args) { 
                MapIfElse mapIfElse = new MapIfElse();
                mapIfElse.doBusiness("1");
            }
    
        }
    
    
    
        //synchronized和ReentrantLock相关的底层实现
        //blockingQueue、Threadpool、Volatile状态标志
        //分布式的paxos和raft算法
    
        /** * 栈队列 先进先出 */
        private void test5(){ 
            PriorityQueue<String> q = new PriorityQueue<>();
            //入列
            q.offer("1");
            q.offer("2");
            q.offer("5");
            q.offer("3");
            q.offer("4");
            //出列
            System.out.println(q.poll());
            //1
            System.out.println(q.poll());
            //2
            System.out.println(q.poll());
            //3
            System.out.println(q.poll());
            //4
            System.out.println(q.poll());
            //5
        }
    
    }

package com.citydo.faceadd.asyncandsynchro;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public abstract class AsycCallBack { 
    
        protected AsyncCall asyncCall = new AsyncCall();
    
        public abstract void callback(long response);
    
        public void call(){ 
            log.info("开始调用");
            asyncCall.call(this);
            log.info("结束调用");
        }
    }

package com.citydo.faceadd.asyncandsynchro;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    @Slf4j
    public class AsyncCall { 
    
        private Random random = new Random(System.currentTimeMillis());
    
        private ExecutorService pool = Executors.newSingleThreadExecutor();
    
        /** * 使用CountDownLatch * 使用CyclicBarrier * 使用wait和notify方法 * rxjava * @param asycCallBack */
        public void call(AsycCallBack asycCallBack){ 
            new Thread(()->{ 
                int nextInt = random.nextInt(10);
                try { 
                    Thread.sleep(nextInt * 1000);
                } catch (InterruptedException e) { 
                    log.error("休眠失败：{}",e);
                }
                asycCallBack.callback(nextInt);
            }).start();
        }
    
        /** * Future * @return */
        public Future<Long> futureCall(){ 
            return pool.submit(()-> { 
                long nextInt = random.nextInt(10);
                try { 
                    Thread.sleep(nextInt * 1000);
                } catch (InterruptedException e) { 
                    log.error("休眠失败：{}",e);
                }
                return nextInt;
            });
    
        }
    
        public void shutdown(){ 
            pool.shutdown();
        }
    
    }

package com.citydo.faceadd.asyncandsynchro;
    
    public interface AsyncService { 
    
        void asyncInvoke(String async) throws RuntimeException;
    
        @FunctionalInterface interface String{ 
            void exec() throws RuntimeException;
        }
    }

package com.citydo.faceadd.asyncandsynchro;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Service;
    
    @Service
    public class AsyncServiceImpl implements AsyncService { 
    
    
        @Async
        @Override
        public void asyncInvoke(String async) throws RuntimeException { 
            async.exec();
        }
    }

## 二、GO相关开源框架与工具 ##

**1、Revel**

作为 Go 语言的高效生产力框架，Revel 包含的 Hot Code Reload 工具可以让你在每次更改文件时重建项目。它还包括各种全面和高性能的功能，因此你不需要找外部库集成到框架中。

**2、Beego**

Beego 是一个完整的 MVC 框架，有自己的日志库、ORM 和 Web 框架。你不需要再去安装第三方库。它有一个称为 Bee Tool 的内置工具，用于监视代码更改，并在检测到更改时运行任务。

Beego 可以为你节省很多时间，特别是在项目一开始，你要弄清楚日志框架或应用程序结构的时候。

**3、Martini**

受 Sinatra 启发，Martini 是一个极其轻巧但功能强大的框架。它被开发用于用 Golang 编写模块化 Web 应用程序和服务。

它的特点是非侵入式设计，快速易用，且包括各种处理程序和中间件。它能够为 HTML5 模式的 AngularJS 应用程序执行基本路由，异常处理和默认文档服务。

Martini 的最佳功能是可以使用反射，它允许开发人员动态地将数据插入到处理函数中并添加新的服务。Martini 也完全兼容 http.HandlerFunc 界面。不过，缺点在于 Martini 框架不再维护了。

**4、Gin Gonic**

Gin Gonic 是一个 Web 框架，有类似 Martini 的 API，但性能更好。如果你以前使用过 Martini，那么你也一定熟悉 Gin Gonic。没用过 Martini 也没关系，只需要学习 10 分钟就能掌握 Gin。就是这么容易！