代码练习
一、练习代码案例
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。就是这么容易！
Gin Gonic 是一个极简化的框架，仅包含最重要的库和功能。这使得它非常适合开发高性能 REST API。此外，它比 Martini 快四十倍。
你可以添加中间件、嵌套组、JSON 验证以及渲染，并依然保持其最佳性能。Gin Gonic 使用 httprouter，Go 语言最快的 HTTP 路由器。
5、Buffalo
要构建 Go 语言新的 Web 应用程序，使用 Buffalo 是一个快速又简单的方法。当你开始一个新项目时，Buffalo 可以为你提供一切——从前端到后端开发。
它具有热重载功能，这意味着 dev 命令将自动查看.go 和.html 文件。然后，它将为你重建并重启二进制文件。运行 dev 命令，你就能看到变化在你的眼前发生！
Buffalo 不仅仅是一个框架——它也是一个整体的 Web 开发生态系统，可以让你直接构建应用程序。
6、Goji
Goji 是一个轻量级的快速 Web 框架，将可组合性和简单性作为其主要优先级。很像 net / http.ServeMux，Goji 是一个极简的 HTTP 请求复用器。它包括 Einhorn 支持，允许在 Goji 中提供 Websocket 支持。
其他功能包括 URL 模式，可重新配置的中间件堆栈，正常关机等。Goji 可以用于生产，并在若干组织中提供了数以亿计个请求。
7、Tiger Tonic
受 Dropwizard 启发，Tiger Tonic 是开发 JSON Web 服务和构建高性能 REST API 的 Go 框架。为了忠于 Golang 的原则，Tiger Tonic 努力保持正交特性。
Tiger Tonic 的缺点在于构建大型后端应用程序尚有不足之处。
8、Gocraft
这是又一个强大而简约的框架，Gocraft 提供快速和可扩展的路由性能。它将路由添加来自标准库的 net / http 包中。
Gocraft 是一个 Go mux 和中间件软件包，具有强大的投射和反射能力，可以静态输入代码。你还可以使用内置中间件添加可选功能或者自己编写。
由于性能始终是开发人员最关心的问题之一，所以 Gocraft 是开发人员的绝佳选择。而且使用 Gocraft 框架编写后端 Web 应用程序很容易。
9、Mango
虽然 Mango 没有得到创作者 Paul Bellamy 的积极维护，但 Go 语言的许多用户仍然在使用它。Mango 的优势在于它的模块化。你可以从各种库中选择，以包含在你的项目中。
Mango 让你可以尽可能快速又轻松地构建可重复使用的 HTTP 功能模块。它将一系列中间件和应用程序编译成单个 HTTP 服务器对象，以保持代码独立。
10、Echo
高性能，可扩展，极简的 Go Web 框架。Echo 是一个轻量级框架，支持自动 TLS、极强扩展性、支持 HTTP/2、数据绑定和校验、模板、定制化和中间件，优化过的路由，性能和 httprouter 不相上下。值得试用。