nohup java -Xmx4000m -Xms4000m -Xmn2g -Xss256k -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

nohup java -Xmx4000m -Xms4000m -Xmn2g -Xss256k -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log  -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

-XX:+PrintGCDetails 打印GC详细信息
-XX:+PrintGCTimeStamps 打印GC时间信息
-XX:+PrintGCDateStamps 打印GC日期的信息
-XX:+PrintHeapAtGC 打印GC堆内存信息
-Xloggc:gc.log 把gc信息输出gc.log文件中

nohup java -Xmx4000m -Xms4000m -Xmn1500m -Xss256k -XX:MetaspaceSize=256m -XX:SurvivorRatio=8 -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log  -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

nohup java -Xmx4000m -Xms4000m -Xmn1500m -Xss256k -XX:MetaspaceSize=256m -XX:SurvivorRatio=8 -XX:+UseParallelGC -XX:+UseParallelOldGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log  -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

nohup java -Xmx4000m -Xms4000m -Xmn1500m -Xss256k -XX:MetaspaceSize=256m -XX:SurvivorRatio=8 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log  -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

nohup java -Xmx4000m -Xms4000m -Xmn1500m -Xss256k -XX:MetaspaceSize=256m -XX:SurvivorRatio=8 -XX:+UseG1GC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.config.addition-location=application.yaml > jshop.log 2>&1 &

datasource:
#url: jdbc:mysql://127.0.0.1:3306/shop?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
  url: jdbc:mysql://XX.XX.XX.XX:3306/shop?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&connectionTimeout=3000&socketTimeout=1200
  username: root
  password: root
  driver-class-name: com.mysql.jdbc.Driver
  druid:
    #配置初始化大小、最小、最大
    initial-size: 1
    min-idle: 5
    max-active:10
    max-wait: 10000
    time-between-eviction-runs-millis: 600000
    # 配置一个连接在池中最大空闲时间，单位是毫秒
    min-evictable-idle-time-millis:300000
    # 设置从连接池获取连接时是否检查连接有效性，true时，每次都检查;false时，不检查
    test-on-borrow: true
    #设置往连接池归还连接时是否检查连接有效性，true时，每次都检查;false时，不检查
    test-on-return: true
    # 设置从连接池获取连接时是否检查连接有效性，true时，如果连接空闲时间超过minEvictableIdleTimeMillis进行检查，否则不检查;false时，不检查
    test-while-idle: true
    # 检验连接是否有效的查询语句。如果数据库Driver支持ping()方法，则优先使用ping()方法进行检查，否则使用validationQuery查询进行检查。(Oracle jdbc Driver目前不支持ping方法)
    validation-query: select 1 from dual
    keep-alive: true
    remove-abandoned: true
    remove-abandoned-timeout: 80
    log-abandoned: true
    #打开PSCache，并且指定每个连接上PSCache的大小，Oracle等支持游标的数据库，打开此开关，会以数量级提升性能，具体查阅PSCache相关资料
    pool-prepared-statements:true
    max-pool-prepared-statement-per-connection-size:20
    # 配置间隔多久启动一次DestroyThread，对连接池内的连接才进行一次检测，单位是毫秒。
    #检测时:
    #1.如果连接空闲并且超过minIdle以外的连接，如果空闲时间超过minEvictableIdleTimeMillis设置的值则直接物理关闭。
    #2.在minIdle以内的不处理。

# 单位是ms
jdbc:mysql://XX.XX.XX.XX:3306/shop?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
&connectionTimeout=3000&socketTimeout=1200

# 安装openresty:
 1、wget https://openresty.org/download/openresty-1.19.3.1.tar.gz
 2、tar -zxvf
 3、./configure
 4、make && make install # 默认被安装到/usr/local/openresty
# content_by_lua 接入lua脚本
location /lua1 {
            default_type text/html;
            content_by_lua 'ngx.say("hello lua!!")';
      }
# content_by_lua_file 通过文件的方式引入lua脚本
location /lua2 {
            default_type text/html;
            content_by_lua_file lua/test.lua; #  test.java ,test.py
        }
# test.lua
local args = ngx.req.get_uri_args()  # 获取参数对象
ngx.say("hello openresty! lua is so easy!==="..args.id)  # 获取参数值，组装值：..
# 转发请求
location /lua3 {
            content_by_lua_file lua/details.lua;
}
# details.lua
ngx.exec('/seckill/goods/detail/1'); # 转发请求

-- 基于内存字典实现缓存
-- 添加缓存实现
function set_to_cache(key,value,expritime)
    -- 判断时间是否存在
    if not expritime then
        expritime = 0
    end
    -- 获取本地内存字典对象
    local ngx_cache = ngx.shared.ngx_cache

    -- 向本地内存字典添加缓存数据
    local succ,err,forcibel = ngx_cache:set(key,vlaue,expritime)

    return succ
end

-- 获取缓存实现
function get_from_cache(key)
    -- 获取本地内存字典对象
    local ngx_cache = ngx.shared.ngx_cache
    -- 从本地内存字典中获取数据
    local value = ngx_cache:get(key)
    return value
end

-- 利用lua脚本实现一些简单业务
-- 获取请求参数对象
local params = ngx.req.get_uri_args()
-- 获取参数
local id = params.id

-- 先从内存字典获取缓存数据
local goods = get_from_cache("seckill_goods_"..id)
-- 如果内存字典中没有缓存数据
if goods == nil then
    -- 从后端服务（缓存，数据库）查询数据，完毕在放入内存字典缓存即可
    local  res = ngx.location.capture("/seckill/goods/detail/"..id)
    -- 获取查询结果
    goods = res.body

    -- 向本地内存字典添加缓存数据
    set_to_cache("seckill_goods_"..id,goods,60)
end
-- 返回结果
ngx.say(goods)

@Transactional
@Override
public HttpResult startKilled(Long killId, String userId) {
   try {
      //实现一个加锁的动作
      lock.lock();
 // do your business
   } catch (Exception e) {
      e.printStackTrace();
   }finally {
      lock.unlock();
   }
   return null;
}

/**
* @ClassName ServiceLock
 * @Description
 * @Author Ylc
 * @Date 2022/5/28 23:12
 * @Version V1.0
 **/
@Target({ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ServiceLock {
    String descripiton() default "";
}
/**
 * @ClassName LockAspect
 * @Description
 * @Author ylc
 * @Date 2022/5/28 23:13
 * @Version V1.0
 **/
@Component
@Scope
@Aspect
@Order(1)
public class LockAspect {
    // 定义锁对象
    private static Lock lock = new ReentrantLock(true);
    // service 切入点
    @Pointcut("@annotation(com.sugo.seckill.aop.ServiceLock)")
    public void lockAspect(){
    }
    @Around("lockAspect()")
    public Object around(ProceedingJoinPoint joinPoint){
        Object obj = null;
        // 开始加锁-- 方法增强
        lock.lock();
        try {
            //执行业务
            obj = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }finally {
            // 释放锁
            lock.unlock();
        }
        return obj;
    }
}