shell复制代码# ulimit -n
1024

csharp复制代码[alert] 13576#0: accept() failed (24: Too many open files)

bash复制代码ulimit -n 655350

ini复制代码worker_rlimit_nofile 655350;

bash复制代码vim /etc/security/limits.conf

markdown复制代码* soft nofile 655360
* hard nofile 655360

ini复制代码#/etc/nginx/conf.d文件夹下面文件排序方式
testserver1.conf　testserver2.conf

#testserver1.conf
server{
	listen 80;
	server_name testserver1 juejin.com;
	location {
		root /opt/app/code1;
		index index.html;
	}
}

#testserver2.conf
server{
	listen 80;
	server_name testserver2 juejin.com;
	location {
		root /opt/app/code2
		index index.html;
	}
}

ini复制代码sysctl -w vm.extra_free_kbytes=6463787
sysctl -w vm.vfs_cache_pressure=10000

less复制代码//格式1
try_files *file* ... *uri*; 
//格式2
try_files *file* ... =*code*;

bash复制代码location /images/ {
root /ht/;
try_files $uri $uri/ /images/default.gif;
}

perl复制代码server {
 listen 80;
 server_name www.juejin.com # 这里指定自己的域名
}
server｛
 listen 80 default_server; # 默认优先返回
 server_name _; # 空主机头或IP
 return 500; # 返回500错误
}
也可以将流量集中导入自己的网站，只要做以下跳转设置就可以

server {
 listen 80 default_server;
 return 302 https://www.juejin.com;
}

bash复制代码server {
 listen 80;
 server_name juejin.com;
 location / {
 set $allow true;
 if ($http_x_forwarded_for ~ "127.0.*.*|127.0.0.120|127.0.0.130"){
 set $allow false;
 }
 if ($allow = false){
 return 403;
 }
 }
}

bash复制代码location [=|~|~*|^~] /uri/ { … }

ini复制代码location = / {
   #规则A
}
location = /login {
   #规则B
}
location ^~ /static/ {
   #规则C
}
location ~ \.(gif|jpg|png|js|css)$ {
   #规则D
}
location ~* \.png$ {
   #规则E
}
location / {
   #规则F
}

ini复制代码server {
 listen 80;
 server_name www.juejin.com;
 location /image/ {
 root /code;
 }
}

bash复制代码server {
 listen 80;
 server_name www.juejin.com;
 location /image/ {
 alias /code;
 }
}

ini复制代码# cat proxy.conf
server {
 listen 80;
 server_name test.juejin.com;
 location / {
 proxy_pass http://127.0.0.1:8080;
 proxy_intercept_errors on; #接收后端web4xx，5xx错误
 error_page 500 502 403 404 = /proxy_error.html; #将后端web抛出的错误定向到指定的页面
 }
 #如果有请求proxy_error.html文件的则指定到对应的目录
 location = /proxy_error.html {
 root /code/proxy;
 }
}

ini复制代码# cat web.conf
server {
 listen 8080;
 server_name test.juejin.com;
 root /code/web;
 index index.html;
 error_page 404 /404.html; #如果代理开启proxy_intercept_errors则后端web配置error_page无效
}

js复制代码       <filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

js复制代码  @RequestMapping(value="/login",method=RequestMethod.GET)
    public String login(HttpServletRequest request,HttpServletResponse response){
        //获取Cookie
        Cookie[] cookies = request.getCookies();
        for(Cookie cookie : cookies){
            System.out.println("cookie>>"+cookie.getValue());
            //从数据库获取保存的cookie
            Session session = iSessionDAO.getSession(cookie.getValue());
            if(session!=null){
                //如果存在，就跳转到首页
                return "index";
            }
        }
        return "login";
    }
    
    @RequestMapping(value="/login",method=RequestMethod.POST)
    public String loginPOST(HttpServletRequest request, HttpServletResponse response,Model model){
        //用户名
        String username=request.getParameter("username");  
        System.out.println("username>>>"+username);
        //密码
        String password=request.getParameter("password"); 
        System.out.println("password>>>"+password);
        //先从数据库查找该账号信息
        User user = null;
        try {
            user = iUserDAO.queryForUser(username);
        } catch (NullPointerException e) {
            e.printStackTrace();
            model.addAttribute("message", "No account");
        }
        if(user==null){
            model.addAttribute("message", "No account");
        }else{
            // 匹配密码
            if (user.getPassword().equals(password)) {
                //登录成功，保存session
                request.getSession().setAttribute("user", user);
                // 保存cookie
                Cookie[] cookies = request.getCookies();
                Cookie cookie = cookies[0];//获得最新的那个cookie
                Session isSession = iSessionDAO.getSessionByUserId(user.getId());
                //没有session，就添加
                if(isSession==null){
                    Session session = new Session();
                    session.setId(UUID.randomUUID().toString());
                    session.setSession(cookie.getValue());
                    session.setUser_id(user.getId());
                    System.out.println("cookie>>" + cookie.getValue());
                    iSessionDAO.save(session);
                    System.out.println("==添加session==");
                }else{
                    //如果已经有session，就更新
                    isSession.setSession(cookie.getValue());
                    iSessionDAO.update(isSession);
                    System.out.println("==更新session==");
                }
                model.addAttribute("message", user.getUsername());
                return "index";
            }else{
                model.addAttribute("message", "Wrong password");
            }
        }
        return "login";
    }

    @RequestMapping(value="/sessionTest",method=RequestMethod.GET)
    public String sessionTest(HttpServletRequest request,HttpServletResponse response,Model model){
        System.out.println(">>>sessionTest");
        model.addAttribute("message", "sessionTest");
        return "index";

    }

js复制代码    <filter>
        <description>session过滤器</description>
        <filter-name>sessionFilter</filter-name>
        <filter-class>com.mocha.filter.SessionFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>sessionFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

js复制代码@Component
public class HandlerInterceptor extends HandlerInterceptorAdapter {

	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {

		System.out.println("11111111");
	}
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {

		System.out.println("222222222");
	}

	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("44444");
		return true;
	}
}

js复制代码    <mvc:interceptors>
		<mvc:interceptor>
			<!--配置拦截器的作用路径 -->
			<mvc:mapping path="/**" />
			<!--定义在<mvc:interceptor>下面的表示匹配指定路径的请求才进行拦截 -->
			<bean class="com.HandlerInterceptor" />
		</mvc:interceptor>
	</mvc:interceptors>

js复制代码import org.springframework.context.ApplicationEvent;
public class MyTestEvent extends ApplicationEvent{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String msg ;
    public MyTestEvent(Object source,String msg) {
        super(source);
        this.msg = msg;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

js复制代码import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

import com.mu.event.MyTestEvent;

@Component
public class MyNoAnnotationListener implements ApplicationListener<MyTestEvent>{

    @Override
    public void onApplicationEvent(MyTestEvent event) {
        System.out.println("非注解监听器：" + event.getMsg());
    }
}

js复制代码package com.mu.event;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class MyTestEventPubLisher {
    @Autowired
    private ApplicationContext applicationContext;
    // 事件发布方法
    public void pushListener(String msg) {
        applicationContext.publishEvent(new MyTestEvent(this, msg));
    }
}

js复制代码import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.mu.event.MyTestEventPubLisher;
@Controller
public class TestEventListenerController {
    @Autowired
    private MyTestEventPubLisher publisher;
    @RequestMapping(value = "/test/testPublishEvent1" )
    public void testPublishEvent(){
        publisher.pushListener("我来了！");
    }
}

js复制代码import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import com.mu.event.MyTestEvent;

@Component
public class MyAnnotationListener {

    @EventListener
    public void listener1(MyTestEvent event) {
        System.out.println("注解监听器1:" + event.getMsg());
    }
}

js复制代码 <listener>    
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>    
  </listener>

js复制代码    @Override
	public void contextInitialized(ServletContextEvent event) {
		initWebApplicationContext(event.getServletContext());
	}

js复制代码     public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
			throw new IllegalStateException(
					"Cannot initialize context because there is already a root application context present - " +
					"check whether you have multiple ContextLoader* definitions in your web.xml!");
		}

		Log logger = LogFactory.getLog(ContextLoader.class);
		servletContext.log("Initializing Spring root WebApplicationContext");
		if (logger.isInfoEnabled()) {
			logger.info("Root WebApplicationContext: initialization started");
		}
		long startTime = System.currentTimeMillis();

		try {
			// Store context in local instance variable, to guarantee that
			// it is available on ServletContext shutdown.
			if (this.context == null) {
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					// The context has not yet been refreshed -> provide services such as
					// setting the parent context, setting the application context id, etc
					if (cwac.getParent() == null) {
						// The context instance was injected without an explicit parent ->
						// determine parent for root web application context, if any.
						ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
			if (ccl == ContextLoader.class.getClassLoader()) {
				currentContext = this.context;
			}
			else if (ccl != null) {
				currentContextPerThread.put(ccl, this.context);
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
						WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
			}
			if (logger.isInfoEnabled()) {
				long elapsedTime = System.currentTimeMillis() - startTime;
				logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
			}

			return this.context;
		}
		catch (RuntimeException ex) {
			logger.error("Context initialization failed", ex);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
			throw ex;
		}
		catch (Error err) {
			logger.error("Context initialization failed", err);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
			throw err;
		}
	}

js复制代码servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

shell复制代码Warning: Could not load Loader: java.lang.UnsatisfiedLinkError: no jnijavacpp in java.library.path

c复制代码#include "NativeLibrary.h" 

namespace NativeLibrary { 

    int MyFunc::add(int a, int b) {
        return a + b;
    }
}

c复制代码#include<iostream>

namespace NativeLibrary {

	class MyFunc{
	public:
		MyFunc(){};
		~MyFunc(){};
		int add(int a, int b);
	};
}

c复制代码#include<iostream>
#include"NativeLibrary.h"

using namespace NativeLibrary;

int main(){
	MyFunc myFunc;
	int value = myFunc.add(1, 2);
	std::cout << "add value " << value << std::endl;
	return 0;
}

shell复制代码g++ -std=c++11 -fPIC -shared NativeLibrary.cpp -o libMyFunc.so

shell复制代码g++ test.cpp -o test ./libMyFunc.so

shell复制代码root@docker:~/javacpp/cpp# ./test
add value 3

java复制代码package com.bolingcavalry.javacppdemo;

import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include="NativeLibrary.h",link="MyFunc")
@Namespace("NativeLibrary")
public class Test {
    public static class MyFunc extends Pointer {
        static { Loader.load(); }
        public MyFunc() { allocate(); }
        private native void allocate();

        // to call add functions
        public native int add(int a, int b);
    }

    public static void main(String[] args) {
        MyFunc myFunc = new MyFunc();
        System.out.println(myFunc .add(111,222));
    }
}

shell复制代码javac -cp javacpp-1.5.5.jar com/bolingcavalry/javacppdemo/Test.java

shell复制代码java \
-jar javacpp-1.5.5.jar \
com/bolingcavalry/javacppdemo/Test.java

shell复制代码root@docker:~/javacpp/java# java \
> -jar javacpp-1.5.5.jar \
> com/bolingcavalry/javacppdemo/Test.java
Info: javac -cp javacpp-1.5.5.jar:/root/javacpp/java com/bolingcavalry/javacppdemo/Test.java 
Info: Generating /root/javacpp/java/jnijavacpp.cpp
Info: Generating /root/javacpp/java/com/bolingcavalry/javacppdemo/jniTest.cpp
Info: Compiling /root/javacpp/java/com/bolingcavalry/javacppdemo/linux-x86_64/libjniTest.so
Info: g++ -I/usr/lib/jvm/jdk1.8.0_291/include -I/usr/lib/jvm/jdk1.8.0_291/include/linux /root/javacpp/java/com/bolingcavalry/javacppdemo/jniTest.cpp /root/javacpp/java/jnijavacpp.cpp -march=x86-64 -m64 -O3 -s -Wl,-rpath,$ORIGIN/ -Wl,-z,noexecstack -Wl,-Bsymbolic -Wall -fPIC -pthread -shared -o libjniTest.so -lMyFunc 
Info: Deleting /root/javacpp/java/com/bolingcavalry/javacppdemo/jniTest.cpp
Info: Deleting /root/javacpp/java/jnijavacpp.cpp

shell复制代码java -cp javacpp-1.5.5.jar:. com.bolingcavalry.javacppdemo.Test

shell复制代码root@docker:~/javacpp/java# java -cp javacpp-1.5.5.jar:. com.bolingcavalry.javacppdemo.Test
Warning: Could not load Loader: java.lang.UnsatisfiedLinkError: no jnijavacpp in java.library.path
333

shell复制代码root@docker:~# tree /root/javacpp
/root/javacpp
├── cpp
│   ├── libMyFunc.so
│   ├── NativeLibrary.cpp
│   ├── NativeLibrary.h
│   ├── test
│   └── test.cpp
└── java
    ├── com
    │   └── bolingcavalry
    │       └── javacppdemo
    │           ├── linux-x86_64
    │           │   ├── libjniTest.so
    │           │   └── libMyFunc.so
    │           ├── NativeLibrary.h
    │           ├── Test.class
    │           ├── Test.java
    │           └── Test$MyFunc.class
    └── javacpp-1.5.5.jar

6 directories, 12 files

shell复制代码root@docker:~/javacpp/java# java -cp javacpp-1.5.5.jar:. com.bolingcavalry.javacppdemo.Test
Warning: Could not load Loader: java.lang.UnsatisfiedLinkError: no jnijavacpp in java.library.path
333

shell复制代码java -cp lib/*:. com.bolingcavalry.javacppdemo.Test

shell复制代码root@docker:~/javacpp# tree /root/javacpp
/root/javacpp
├── cpp
│   ├── libMyFunc.so
│   ├── NativeLibrary.cpp
│   ├── NativeLibrary.h
│   ├── test
│   └── test.cpp
└── java
    ├── com
    │   └── bolingcavalry
    │       └── javacppdemo
    │           ├── linux-x86_64
    │           │   ├── libjniTest.so
    │           │   └── libMyFunc.so
    │           ├── NativeLibrary.h
    │           ├── Test.class
    │           ├── Test.java
    │           └── Test$MyFunc.class
    ├── javacpp-1.5.5.jar
    └── lib
        ├── javacpp-1.5.5-android-arm64.jar
        ├── javacpp-1.5.5-android-arm.jar
        ├── javacpp-1.5.5-android-x86_64.jar
        ├── javacpp-1.5.5-android-x86.jar
        ├── javacpp-1.5.5-ios-arm64.jar
        ├── javacpp-1.5.5-ios-x86_64.jar
        ├── javacpp-1.5.5.jar
        ├── javacpp-1.5.5-linux-arm64.jar
        ├── javacpp-1.5.5-linux-armhf.jar
        ├── javacpp-1.5.5-linux-ppc64le.jar
        ├── javacpp-1.5.5-linux-x86_64.jar
        ├── javacpp-1.5.5-linux-x86.jar
        ├── javacpp-1.5.5-macosx-arm64.jar
        ├── javacpp-1.5.5-macosx-x86_64.jar
        ├── javacpp-1.5.5-windows-x86_64.jar
        ├── javacpp-1.5.5-windows-x86.jar
        └── javacpp-platform-1.5.5.jar

7 directories, 29 files

cpp复制代码if (type == LOG_CHECKPOINT) {
    recv_sys_create();
    recv_sys_init(FALSE, buf_pool_get_curr_size());
}

cpp复制代码struct hash_table_struct {
    ibool        adaptive;/* TRUE if this is the hash table of the
                adaptive hash index */
    ulint        n_cells;/* number of cells in the hash table */
    hash_cell_t*    array;    /* pointer to cell array */

    ulint        n_mutexes;/* if mutexes != NULL, then the number of
                mutexes, must be a power of 2 */
    mutex_t*    mutexes;/* NULL, or an array of mutexes used to
                protect segments of the hash table */
    mem_heap_t**    heaps;    /* if this is non-NULL, hash chain nodes for

                external chaining can be allocated from these
                memory heaps; there are then n_mutexes many of
                these heaps */
    mem_heap_t*    heap;
    ulint        magic_n;

};

cpp复制代码for (field = LOG_CHECKPOINT_1; field <= LOG_CHECKPOINT_2; field += LOG_CHECKPOINT_2 - LOG_CHECKPOINT_1) {
            log_group_read_checkpoint_info(group, field);
            if (!recv_check_cp_is_consistent(buf)) {
                goto not_consistent;
            }
            group->state = LOG_GROUP_OK;
            group->lsn = mach_read_from_8(buf + LOG_CHECKPOINT_LSN);
            group->lsn_offset = mach_read_from_4(buf + LOG_CHECKPOINT_OFFSET);
            checkpoint_no = mach_read_from_8(buf + LOG_CHECKPOINT_NO);
            if (ut_dulint_cmp(checkpoint_no, max_no) >= 0) {
                *max_group = group;
                *max_field = field;
                max_no = checkpoint_no;
            }
        not_consistent:
            ;
}

cpp复制代码void log_group_read_checkpoint_info(
    log_group_t*    group,    /* in: log group */
    ulint        field)    /* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */

{
    log_sys->n_log_ios++;
    fil_io(OS_FILE_READ | OS_FILE_LOG, TRUE, group->space_id,
            field / UNIV_PAGE_SIZE, field % UNIV_PAGE_SIZE,
            OS_FILE_LOG_BLOCK_SIZE, log_sys->checkpoint_buf, NULL);
}

cpp复制代码while (!finished)
{
    end_lsn = ut_dulint_add(start_lsn, RECV_SCAN_SIZE);
    log_group_read_log_seg(LOG_RECOVER, log_sys->buf, group, start_lsn, end_lsn);
    finished = recv_scan_log_recs(TRUE,
    (buf_pool->n_frames - recv_n_pool_free_frames) * UNIV_PAGE_SIZE,
    TRUE, log_sys->buf,
    RECV_SCAN_SIZE, start_lsn,
    contiguous_lsn, group_scanned_lsn);
    start_lsn = end_lsn;
}

cpp复制代码old_lsn = recv_sys->recovered_lsn;
len = recv_parse_log_rec(ptr, end_ptr, &type, &space, &page_no, &body);
if (recv_sys->found_corrupt_log) {
    recv_report_corrupt_log(ptr,
                type, space, page_no);
}

ut_a(len != 0);
ut_a(0 == ((ulint)*ptr & MLOG_SINGLE_REC_FLAG));
recv_sys->recovered_offset += len;
recv_sys->recovered_lsn = recv_calc_lsn_on_data_add(old_lsn, len);
if (type == MLOG_MULTI_REC_END) {
    /* Found the end mark for the records */
    break;
}
if (store_to_hash) {
    recv_add_to_hash_table(type, space, page_no, body, ptr + len, old_lsn, new_recovered_lsn);
}
ptr += len;

cpp复制代码static ulint recv_read_in_area(
    ulint    space,    /* in: space */
    ulint    page_no)/* in: page number */
{
    recv_addr_t* recv_addr;
    ulint    page_nos[RECV_READ_AHEAD_AREA];
    ulint    low_limit;
    ulint    n;
    low_limit = page_no - (page_no % RECV_READ_AHEAD_AREA);
    n = 0;
    for (page_no = low_limit; page_no < low_limit + RECV_READ_AHEAD_AREA;page_no++) {
        recv_addr = recv_get_fil_addr_struct(space, page_no);
        if (recv_addr && !buf_page_peek(space, page_no)) {

            mutex_enter(&(recv_sys->mutex));

            if (recv_addr->state == RECV_NOT_PROCESSED) {
                recv_addr->state = RECV_BEING_READ;
    
                page_nos[n] = page_no;
                n++;
            }
            
            mutex_exit(&(recv_sys->mutex));
        }
    }
    buf_read_recv_pages(FALSE, space, page_nos, n);
    return(n);
}

xml复制代码<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.0</version>
</dependency>

java复制代码public class RedissonTest {

    private static RedissonClient redissonClient;

    static {
        Config config=new Config();
        config.useSingleServer().setAddress("redis://192.168.221.128:6379");
        redissonClient=Redisson.create(config);
    }

    public static void main(String[] args) throws InterruptedException {
        RLock rLock=redissonClient.getLock("updateOrder");
        //最多等待100秒、上锁10s以后自动解锁
        if(rLock.tryLock(100,10,TimeUnit.SECONDS)){
            System.out.println("获取锁成功");
        }
        Thread.sleep(2000);
        rLock.unlock();

        redissonClient.shutdown();
    }
}

java复制代码@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    long time = unit.toMillis(waitTime);
    long current = System.currentTimeMillis();
    long threadId = Thread.currentThread().getId();
    //通过tryAcquire方法尝试获取锁
    Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
    // lock acquired
    if (ttl == null) { //表示成功获取到锁，直接返回
        return true;
    }
	//省略部分代码....
}

java复制代码private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    RFuture<Long> ttlRemainingFuture;
    //leaseTime就是租约时间，就是redis key的过期时间。
    if (leaseTime != -1) { //如果设置过期时间
        ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    } else {//如果没设置了过期时间，则从配置中获取key超时时间,默认是30s过期
        ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                                               TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    }
    //当tryLockInnerAsync执行结束后，触发下面回调
    ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
        if (e != null) { //说明出现异常，直接返回
            return;
        }
        // lock acquired
        if (ttlRemaining == null) { //表示第一次设置锁键
            if (leaseTime != -1) { //表示设置过超时时间，更新internalLockLeaseTime，并返回
                internalLockLeaseTime = unit.toMillis(leaseTime);
            } else { //leaseTime=-1,启动Watch Dog
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}

java复制代码<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
                          "if (redis.call('exists', KEYS[1]) == 0) then " +
                          "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                          "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                          "return nil; " +
                          "end; " +
                          "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                          "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                          "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                          "return nil; " +
                          "end; " +
                          "return redis.call('pttl', KEYS[1]);",
                          Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
}

java复制代码protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                          "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                          "return nil;" +
                          "end; " +
                          "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                          "if (counter > 0) then " +
                          "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                          "return 0; " +
                          "else " +
                          "redis.call('del', KEYS[1]); " +
                          "redis.call('publish', KEYS[2], ARGV[1]); " +
                          "return 1; " +
                          "end; " +
                          "return nil;",
                          Arrays.asList(getRawName(), getChannelName()), LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId));
}

java复制代码public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
//省略部分代码
        time -= System.currentTimeMillis() - current;
        if (time <= 0) {
            acquireFailed(waitTime, unit, threadId);
            return false;
        }
        current = System.currentTimeMillis();
       // 订阅监听redis消息，并且创建RedissonLockEntry
        RFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);
      // 阻塞等待subscribe的future的结果对象，如果subscribe方法调用超过了time，说明已经超过了客户端设置的最大wait time，则直接返回false，取消订阅，不再继续申请锁了。
        if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {
            if (!subscribeFuture.cancel(false)) { //取消订阅
                subscribeFuture.onComplete((res, e) -> {
                    if (e == null) {
                        unsubscribe(subscribeFuture, threadId);
                    }
                });
            }
            acquireFailed(waitTime, unit, threadId); //表示抢占锁失败
            return false; //返回false
        }
        try {
            //判断是否超时，如果等待超时，返回获的锁失败
            time -= System.currentTimeMillis() - current;
            if (time <= 0) {
                acquireFailed(waitTime, unit, threadId);
                return false;
            }
            //通过while循环再次尝试竞争锁
            while (true) { 
                long currentTime = System.currentTimeMillis();
                ttl = tryAcquire(waitTime, leaseTime, unit, threadId); //竞争锁，返回锁超时时间
                // lock acquired
                if (ttl == null) { //如果超时时间为null，说明获得锁成功
                    return true;
                }
                //判断是否超时，如果超时，表示获取锁失败
                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) {
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }

                // 通过信号量(共享锁)阻塞,等待解锁消息.  (减少申请锁调用的频率)
				// 如果剩余时间(ttl)小于wait time ,就在 ttl 时间内，从Entry的信号量获取一个许可(除非被中断或者一直没有可用的许可)。
				// 否则就在wait time 时间范围内等待可以通过信号量
                currentTime = System.currentTimeMillis();
                if (ttl >= 0 && ttl < time) {
                    subscribeFuture.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } else {
                    subscribeFuture.getNow().getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                }
                // 更新等待时间(最大等待时间-已经消耗的阻塞时间)
                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) { //获取锁失败
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }
            }
        } finally {
            unsubscribe(subscribeFuture, threadId); //取消订阅
        }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
    }

java复制代码@Override
public boolean tryLock(long waitTime, TimeUnit unit) throws InterruptedException {
    return tryLock(waitTime, -1, unit);  //leaseTime=-1
}

java复制代码private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    RFuture<Long> ttlRemainingFuture;
    if (leaseTime != -1) { 
        ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    } else { //当leaseTime为-1时，leaseTime=internalLockLeaseTime，默认是30s，表示当前锁的过期时间。
        
        //this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
        ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                                               TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    }
    ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
        if (e != null) { //说明出现异常，直接返回
            return;
        }
        // lock acquired
        if (ttlRemaining == null) { //表示第一次设置锁键
            if (leaseTime != -1) { //表示设置过超时时间，更新internalLockLeaseTime，并返回
                internalLockLeaseTime = unit.toMillis(leaseTime);
            } else { //leaseTime=-1,启动Watch Dog
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}

java复制代码protected void scheduleExpirationRenewal(long threadId) {
    ExpirationEntry entry = new ExpirationEntry();
    ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
    if (oldEntry != null) {
        oldEntry.addThreadId(threadId);
    } else {// 第一次加锁的时候会调用，内部会启动WatchDog
        entry.addThreadId(threadId);
        renewExpiration();
    
    }
}

java复制代码private void renewExpiration() {
    ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (ee == null) {
        return;
    }
	//用到了时间轮机制
    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
            if (ent == null) {
                return;
            }
            Long threadId = ent.getFirstThreadId();
            if (threadId == null) {
                return;
            }
            // renewExpirationAsync续约租期
            RFuture<Boolean> future = renewExpirationAsync(threadId);
            future.onComplete((res, e) -> {
                if (e != null) {
                    log.error("Can't update lock " + getRawName() + " expiration", e);
                    EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                    return;
                }

                if (res) {
                    // reschedule itself
                    renewExpiration();
                }
            });
        }
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);//每次间隔租期的1/3时间执行

    ee.setTimeout(task);
}

java复制代码protected RFuture<Boolean> renewExpirationAsync(long threadId) {
    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                          "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                          "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                          "return 1; " +
                          "end; " +
                          "return 0;",
                          Collections.singletonList(getRawName()),
                          internalLockLeaseTime, getLockName(threadId));
}

shell复制代码tar -zxvf lua-5.4.3.tar.gz
cd lua-5.4.3
make linux
make install

java复制代码yum -y install readline-devel ncurses-devel

lua复制代码array = {"Lua", "mic"}
for i= 0, 2 do
   print(array[i])
end

shell复制代码array = {"mic", "redis"}

for key,value in ipairs(array)
do
   print(key, value)
end

shell复制代码redis.call(‘set’,'hello','world')

local value=redis.call(‘get’,’hello’)

shell复制代码eval "return redis.call('set',KEYS[1],ARGV[1])" 1 lua hello

shell复制代码# 将脚本加入缓存并生成sha1命令
script load "return redis.call('get','lua')"
# ["13bd040587b891aedc00a72458cbf8588a27df90"]
# 传递sha1的值来执行该命令
evalsha "13bd040587b891aedc00a72458cbf8588a27df90" 0

lua复制代码local times=redis.call('incr',KEYS[1])
-- 如果是第一次进来，设置一个过期时间
if times == 1 then
   redis.call('expire',KEYS[1],ARGV[1])
end
-- 如果在指定时间内访问次数大于指定次数，则返回0，表示访问被限制
if times > tonumber(ARGV[2]) then
   return 0
end
-- 返回1，允许被访问
return 1

java复制代码@RestController
public class RedissonController {
    @Autowired
    RedissonClient redissonClient;

    private final String LIMIT_LUA=
        "local times=redis.call('incr',KEYS[1])\n" +
        "if times == 1 then\n" +
        "   redis.call('expire',KEYS[1],ARGV[1])\n" +
        "end\n" +
        "if times > tonumber(ARGV[2]) then\n" +
        "   return 0\n" +
        "end\n" +
        "return 1";

    @GetMapping("/lua/{id}")
    public String lua(@PathVariable("id") Integer id) throws ExecutionException, InterruptedException {
        List<Object> keys= Arrays.asList("LIMIT:"+id);
        RFuture<Object> future=redissonClient.getScript().
            evalAsync(RScript.Mode.READ_WRITE,LIMIT_LUA, RScript.ReturnType.INTEGER,keys,10,3);
        return future.get().toString();
    }

}

yml复制代码spring:
  redis:
    redisson:
      file: classpath:redisson.yml

yml复制代码singleServerConfig:
  address: redis://192.168.221.128:6379

codec: !<org.redisson.codec.JsonJacksonCodec> {}

shell复制代码eval "while true do end" 0

txt复制代码(error) BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.

shell复制代码eval "redis.call('set','name','mic') while true do end" 0

shell复制代码get lua

txt复制代码(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the script termination or kill the server in a hard way using the SHUTDOWN NOSAVE command.

java复制代码<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
                          "if (redis.call('exists', KEYS[1]) == 0) then " +
                          "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                          "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                          "return nil; " +
                          "end; " +
                          "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                          "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                          "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                          "return nil; " +
                          "end; " +
                          "return redis.call('pttl', KEYS[1]);",
                          Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
}

java复制代码protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    return evalWriteAsync(getRawName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                          "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                          "return nil;" +
                          "end; " +
                          "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
                          "if (counter > 0) then " +
                          "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                          "return 0; " +
                          "else " +
                          "redis.call('del', KEYS[1]); " +
                          "redis.call('publish', KEYS[2], ARGV[1]); " +
                          "return 1; " +
                          "end; " +
                          "return nil;",
                          Arrays.asList(getRawName(), getChannelName()), LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId));
}

shell复制代码PUBLISH channel message

shell复制代码PUBLISH channel.1 “hello”

shell复制代码SUBSCRIBE channel [channel …]

go复制代码// Walk 步进 tree t 将所有的值从 tree 发送到 channel ch。
func Walk(t *tree.Tree, ch chan int)

复制代码一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

（4）没有键值相等的结点。

go复制代码  func DFS(t *tree.Tree, ch chan int){
      if t == nil {
          return
      }
      if t.Left != nil {
          DFS(t.Left, ch)
      }
      ch <- t.Value
      if t.Right != nil {
          DFS(t.Right, ch)
      }
  }

go复制代码func Walk(t *tree.Tree, ch chan int) {
    DFS(t,ch)
    close(ch)
}

go复制代码for i :=range ch1{
  j,ok := <- ch2
  if !ok {
      return false
  }
  if i!=j {
      return false
  }
  fmt.Printf("ch1: %v - ch2: %v\n", i, j)
}

go复制代码func Same(t1, t2 *tree.Tree) bool{
    ch1 := make(chan int)
    ch2 := make(chan int)
    go Walk(t1, ch1) 
    go Walk(t2, ch2)
    for i :=range ch1{
      j,ok := <- ch2
      if !ok {
          return false
      }
      if i!=j {
          return false
      }
      fmt.Printf("ch1: %v - ch2: %v\n", i, j)
    }
    return true
}

rust复制代码struct Player {
    x: i32,
    y: i32,
    velocity: f32,
}

rust复制代码impl Player {
    fn new(x: i32, y: i32) -> Self {
        Player {
            x,
            y,
            velocity: 0.0,
        }
    }

    fn render(&mut self, ctx: &mut BTerm) {
        ctx.set(
            0,
            self.y,
            YELLOW,
            BLACK,
            to_cp437('@')
        );
    }
}

rust复制代码fn gravity_and_move(&mut self) {
    if self.velocity < 2.0 {
        self.velocity += 0.2;
    }
    self.y += self.velocity as i32;
    self.x += 1;
    
    if self.y < 0 {
        self.y = 0;
    }
}

fn flap(&mut self) {
    self.velocity = -2.0;
}

rust复制代码struct Obstacle {
    x: i32,
    gap_y: i32,
    size: i32,
}

rust复制代码impl Obstacle {
    fn new(x: i32, score: i32) -> Self {
        let mut random = RandomNumberGenerator::new();
        Obstacle {
            x,
            gap_y: random.range(10, 40),
            size: i32::max(2, 20 -score)
        }
    }

    fn render(&mut self, ctx: &mut BTerm, player_x: i32) {
        let screen_x = self.x - player_x;
        let half_size = self.size / 2;

        for y in 0..self.gap_y - half_size {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }

        for y in self.gap_y + half_size..SCREEN_HEIGHT {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }
    }
}

ini复制代码fn hit_obstacle(&self, player: &Player) -> bool {
    let half_size = self.size / 2;
    let does_x_match = player.x == self.x;
    let player_above_gap = player.y < self.gap_y - half_size;
    let player_below_gap = player.y > self.gap_y + half_size;
    
    does_x_match && (player_above_gap || player_below_gap)
}

python复制代码fn play(&mut self, ctx: &mut BTerm) {
    // TODO: Fill in this stub later
    ctx.cls_bg(NAVY);
    self.frame_time += ctx.frame_time_ms;
    
    if self.frame_time > FRAME_DURATION {
        self.frame_time = 0.0;
        self.player.gravity_and_move();
    }

    if let Some(VirtualKeyCode::Space) = ctx.key {
        self.player.flap();
    }
    self.player.render(ctx);
    ctx.print(0, 0, "按住空格保持飞翔");
    ctx.print(0, 1, &format!("得分：{}", self.score));

    self.obstacle.render(ctx, self.player.x);
    if self.player.x > self.obstacle.x {
        self.score += 1;
        self.obstacle = Obstacle::new(self.player.x + SCREEN_WIDTH, self.score);
    }

    if self.player.y > SCREEN_HEIGHT || self.obstacle.hit_obstacle(&self.player) {
        self.mode = GameMode::End;
    }
}

rust复制代码use bracket_lib::prelude::*;

const SCREEN_WIDTH: i32 = 80;
const SCREEN_HEIGHT: i32 = 50;
const FRAME_DURATION: f32 = 75.0;
struct Player {
    x: i32,
    y: i32,
    velocity: f32,
}

impl Player {
    fn new(x: i32, y: i32) -> Self {
        Player {
            x,
            y,
            velocity: 0.0,
        }
    }

    fn render(&mut self, ctx: &mut BTerm) {
        ctx.set(
            0,
            self.y,
            YELLOW,
            BLACK,
            to_cp437('@')
        );
    }

    fn gravity_and_move(&mut self) {
        if self.velocity < 2.0 {
            self.velocity += 0.2;
        }
        self.y += self.velocity as i32;
        self.x += 1;
        
        if self.y < 0 {
            self.y = 0;
        }
    }

    fn flap(&mut self) {
        self.velocity = -2.0;
    }
}

struct Obstacle {
    x: i32,
    gap_y: i32,
    size: i32,
}

impl Obstacle {
    fn new(x: i32, score: i32) -> Self {
        let mut random = RandomNumberGenerator::new();
        Obstacle {
            x,
            gap_y: random.range(10, 40),
            size: i32::max(2, 20 -score)
        }
    }

    fn render(&mut self, ctx: &mut BTerm, player_x: i32) {
        let screen_x = self.x - player_x;
        let half_size = self.size / 2;

        for y in 0..self.gap_y - half_size {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }

        for y in self.gap_y + half_size..SCREEN_HEIGHT {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }
    }

    fn hit_obstacle(&self, player: &Player) -> bool {
        let half_size = self.size / 2;
        let does_x_match = player.x == self.x;
        let player_above_gap = player.y < self.gap_y - half_size;
        let player_below_gap = player.y > self.gap_y + half_size;
        
        does_x_match && (player_above_gap || player_below_gap)
    }
}

enum GameMode {
    Menu,
    Playing,
    End,
}

struct State {
    player: Player,
    frame_time: f32,
    obstacle: Obstacle,
    mode: GameMode,
    score: i32,
}

impl State {
    fn new() -> Self {
        State {
            player: Player::new(5, 25),
            frame_time: 0.0,
            obstacle: Obstacle::new(SCREEN_WIDTH, 0),
            mode: GameMode::Menu,
            score: 0,
        }
    }

    fn restart(&mut self) {
        self.player = Player::new(5, 25);
        self.frame_time = 0.0;
        self.mode = GameMode::Playing;
    }

    fn main_menu(&mut self, ctx: &mut BTerm) {
        ctx.cls();
        ctx.print_centered(5, "Welcome to Flappy Dragon");
        ctx.print_centered(8, "(P) Play Game");
        ctx.print_centered(9, "(Q) Quit Game");

        if let Some(key) = ctx.key {
            match key {
                VirtualKeyCode::P => self.restart(),
                VirtualKeyCode::Q => ctx.quitting = true,
                _ => {}
            }
        }
        self.player = Player::new(5, 25);
        self.frame_time = 0.0;
        self.obstacle = Obstacle::new(SCREEN_WIDTH, 0);
        self.mode = GameMode::Playing;
        self.score = 0;
    }

    fn dead(&mut self, ctx: &mut BTerm) {
        ctx.cls();
        ctx.print_centered(5, "You are dead!");
        ctx.print_centered(6, &format!("You earned {} points", self.score));
        ctx.print_centered(8, "(P) Play Again");
        ctx.print_centered(9, "(Q) Quit Game");

        if let Some(key) = ctx.key {
            match key {
                VirtualKeyCode::P => self.restart(),
                VirtualKeyCode::Q => ctx.quitting = true,
                _ => {}
            }
        }
    }

    fn play(&mut self, ctx: &mut BTerm) {
        // TODO: Fill in this stub later
        ctx.cls_bg(NAVY);
        self.frame_time += ctx.frame_time_ms;
        
        if self.frame_time > FRAME_DURATION {
            self.frame_time = 0.0;
            self.player.gravity_and_move();
        }

        if let Some(VirtualKeyCode::Space) = ctx.key {
            self.player.flap();
        }
        self.player.render(ctx);
        ctx.print(0, 0, "按住空格保持飞翔");
        ctx.print(0, 1, &format!("得分：{}", self.score));

        self.obstacle.render(ctx, self.player.x);
        if self.player.x > self.obstacle.x {
            self.score += 1;
            self.obstacle = Obstacle::new(self.player.x + SCREEN_WIDTH, self.score);
        }

        if self.player.y > SCREEN_HEIGHT || self.obstacle.hit_obstacle(&self.player) {
            self.mode = GameMode::End;
        }
    }
}

impl GameState for State {
    fn tick(&mut self, ctx: &mut BTerm) {
        // ctx.cls();
        // ctx.print(1, 1, "Hello, Bracket Terminal!");
        match self.mode {
            GameMode::Menu => self.main_menu(ctx),
            GameMode::End => self.dead(ctx),
            GameMode::Playing => self.play(ctx),
        }
    }
}

fn main() ->BError {
    println!("Hello, world!");

    let context = BTermBuilder::simple80x50()
        .with_title("Flappy Dragon")
        .build()?;
    
    main_loop(context, State::new())
}

java复制代码// 强烈建议加上注解 @FunctionalInterface
@FunctionalInterface
public interface Consumer {
    // 唯一的抽象方法
    void accept(T t);

    // 可以有多个非抽象方法（默认方法）
    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

java复制代码@FunctionalInterface
public interface Function<T, R> {
    /**
     * 给定一个类型为 T 的参数 t ，返回一个类型为 R 的响应值。
     *
     * @param t 函数参数
     * @return 执行结果
     */
    R apply(T t);
}

java复制代码public V computeIfAbsent(K key,
                         Function<? super K, ? extends V> mappingFunction);

java复制代码public static void testFunctionWithLambda() {
    // 构建一个HashMap，key是某个单词，value是单词的字母长度
    Map wordMap = new HashMap<>();
    Integer wordLen = wordMap.computeIfAbsent("hello", s -> s.length());
    System.out.println(wordLen);
    System.out.println(wordMap);
}

ini复制代码5
{hello=5}

java复制代码public static int getStringLength(String s) {
    return s.length();
}

java复制代码public static void testFunctionWithMethodReference() {
    Map wordMap = new HashMap<>();
    Integer wordLen = wordMap.computeIfAbsent("hello", String::length);
    System.out.println(wordLen);
    System.out.println(wordMap);
}

java复制代码@FunctionalInterface
public interface BiFunction<T, U, R> {
    /**
     * 给定类型分别为 T 的参数 t 和 类型为 U 的参数 u，返回一个类型为 R 的响应值。
     *
     * @param t 第一个参数
     * @param u 第二个参数
     * @return 执行结果
     */
    R apply(T t, U u);

    ...
}

java复制代码public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)

java复制代码public static void testBiFunctionWithLambda() {
    Map wordMap = new HashMap<>();
    wordMap.put("hello", 5);
    wordMap.put("world", 5);
    wordMap.put("on", 2);
    wordMap.put("at", 2);
    
    // lambda表达式中的k和v，分别是Map中Entry的key和原值value。
    // lambda表达式的返回值是一个新值value。
    wordMap.replaceAll((k, v) -> {
        if ("on".equals(k) || "at".equals(k)) {
            // 对应单词 on 和 at，单词长度统一记录为 0
            return 0;
        } else {
            // 其它单词，单词长度保持原值
            return v;
        }
    });

    System.out.println(wordMap);
}

ini复制代码{world=5, at=0, hello=5, on=0}

java复制代码@FunctionalInterface
public interface Supplier<T> {
    /**
     * 获取一个类型为 T 的对象实例。
     *
     * @return 对象实例
     */
    T get();
}

java复制代码public class SupplierExample {
    public static void main(String[] args) {
        testSupplierWithLambda();
    }
    
    public static void testSupplierWithLambda() {
        final Random random = new Random();

        // 生成一个随机整数
        lazyPrint(() -> {
            return random.nextInt(100);
        });

        // 延时3秒，生成一个随机整数
        lazyPrint(() -> {
            try {
                System.out.println("waiting for 3s...");
                Thread.sleep(3*1000);
            } catch (InterruptedException e) {
                // do nothing
            }

            return random.nextInt(100);
        });
    }

    public static void lazyPrint(Supplier lazyValue) {
        System.out.println(lazyValue.get());
    }
}

erlang复制代码26
waiting for 3s...
27

java复制代码@FunctionalInterface
public interface Consumer<T> {
    /**
     * 对给定的单一参数执行相关操作。
     *
     * @param t 输入参数
     */
    void accept(T t);
    
    ...
}

java复制代码public static void testConsumer() {
    List list = Arrays.asList("Guangdong", "Zhejiang", "Jiangsu");

    // 消费 list 中的每一个元素
    list.forEach(s -> System.out.println(s));
}

复制代码Guangdong
Zhejiang
Jiangsu