makefile复制代码soc-app:162
cid:0
soc-platform:1
ozv:es_oz_20160428.15_p0
f.sid:132385467
_reqid:142769
rt:j

perl复制代码f.req:%5B%5B%22OGB%22%2C%5B7%2C%22en%22%5D%5D%2C%5B%5B%5D%2C%5B1%5D%2C%5B3%5D%2C100%2C%22OGB%22%5D%2C%5B1%5D%5D
at:AObGSAhUe1EYP164z9Z6L0cy8oPPAm_ezw%3A1462071694241
:

maven复制代码<properties>
    <version.spring-cloud>2020.0.1</version.spring-cloud>
</properties>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>${version.spring-cloud}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

maven复制代码<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

java复制代码@SpringBootApplication
@EnableEurekaServer
public class Launcher {

    public static void main(String[] args) {
        SpringApplication.run(Launcher.class,args);
    }
}

properties复制代码server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

maven复制代码<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

java复制代码public interface GreetingController {

    @GetMapping("/greeting")
    String greeting();
}

java复制代码@SpringBootApplication
@RestController
public class Launcher implements GreetingController {

    @Autowired
    @Lazy
    private EurekaClient eurekaClient;

    @Value("${spring.application.name}")
    private String appName;

    @Override
    public String greeting() {
        return String.format(
            "Hello from '%s'!", eurekaClient.getApplication(appName).getName());
    }

    public static void main(String[] args) {
        SpringApplication.run(Launcher.class,args);
    }
}

yml复制代码spring:
  application:
    name: spring-cloud-eureka-client

server:
  port: 0
eureka:
  client:
    serviceUrl:
      defaultZone: ${EUREKA_URI:http://localhost:8761/eureka}
  instance:
    preferIpAddress: true

java复制代码/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) {
    // 判断数组容量是否足够，如果不足，增加1.5倍，size是当前队列长度
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 给下标为size的赋值，同时队列长度+1，下标从0开始
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 判断是否首次添加元素，如果是，返回默认队列长度，现在是10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 如果不是首次添加元素，就返回当前队列长度+1
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    // 如果需要的长度大于队列中数组长度，扩容，如果可以满足需求，就不用扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 这里就是扩容1.5倍的代码
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

java复制代码elementData[size] = e;
size++;

java复制代码public class Main {
    public static void main(String[] args) {
        int[] nums = new int[3];
        int index = 0;
        nums[index++] = 5;
    }
}

less复制代码public class Main
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #3.#12         // java/lang/Object."<init>":()V
   #2 = Class              #13            // Main
   #3 = Class              #14            // java/lang/Object
   #4 = Utf8               <init>
   #5 = Utf8               ()V
   #6 = Utf8               Code
   #7 = Utf8               LineNumberTable
   #8 = Utf8               main
   #9 = Utf8               ([Ljava/lang/String;)V
  #10 = Utf8               SourceFile
  #11 = Utf8               Main.java
  #12 = NameAndType        #4:#5          // "<init>":()V
  #13 = Utf8               Main
  #14 = Utf8               java/lang/Object
{
  public Main();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=3, args_size=1                                                                               局部变量表                             栈
         0: iconst_3                     // 将int型(3)推送至栈顶                                                      args                                3
         1: newarray       int           // 创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶          args                                数组引用
         3: astore_1                     // 将栈顶引用型数值存入第二个本地变量                                            args, nums=数组引用                  null
         4: iconst_0                     // 将int型(0)推送至栈顶                                                       args, nums=数组引用                  0
         5: istore_2                     // 将栈顶int型数值存入第三个本地变量                                             args, nums=数组引用, index=0         null
         6: aload_1                      // 将第二个引用类型本地变量推送至栈顶                                             args, nums=数组引用, index=0         数组引用
         7: iload_2                      // 将第三个int型本地变量推送至栈顶                                               args, nums=数组引用, index=0         0, 数组引用
         8: iinc          2, 1           // 将指定int型变量增加指定值（i++, i--, i+=2），也就是第三个本地变量增加1            args, nums=数组引用, index=1         0, 数组引用
        11: iconst_5                     // 将int型(5)推送至栈顶                                                        args, nums=数组引用, index=1         5, 0, 数组引用
        12: iastore                      // 将栈顶int型数值存入指定数组的指定索引位置                                       args, nums=数组引用, index=1         null
        13: return                       // 从当前方法返回void
      LineNumberTable:
        line 3: 0                        // int[] nums = new int[3];
        line 4: 4                        // int index = 0;
        line 5: 6                        // nums[index++] = 5;
        line 6: 13                       // 方法结尾默认的return
}

bash复制代码// 开始事务
127.0.0.1:6379> multi
OK
// 设置健值
127.0.0.1:6379> set a aaaa
QUEUED
// 设置健值
127.0.0.1:6379> set b bbbb
QUEUED
// 设置健值
127.0.0.1:6379> set c cccc
QUEUED
// 执行事务，其实redis的事务就是一个批处理命令的一个脚本
127.0.0.1:6379> exec
1) OK
2) OK
3) OK

bash复制代码// 开启事务
    $res = $redis->multi();
 
    $res = $redis->set('a','aaa');
    var_dump($res);
    echo "<hr>";
 
    $res = $redis->set('b','bbb');
    var_dump($res);
    echo "<hr>";
 
    $res = $redis->set('c','bbb');
    var_dump($res);
    echo "<hr>";
 
    // 执行事务
    $res = $redis->exec();
 
    var_dump($res);

bash复制代码// 监视 count 值
    $redis->watch("count");
    // 开启事务
    $redis->multi();
    // 操作count
    $time = time();
    $redis->set("count", $time);
 
    // 模拟并发下其他进程进行set count操作 请执行下面操作
    // 在shell命令行中执行 set count issimulate;
 
    sleep(40);
    // 提交事务
    $res = $redis->exec();
 
    $result = $redis->get('count');
 
    if ($res) {
        // 成功...
        echo "success:" . $result ;
        echo "<hr>";
        return;
    }
    // 失败...
    echo "fail:" . $result ;
    echo "<hr>";

bash复制代码Success：1502547852

bash复制代码fail:issimulate

bash复制代码DISCARD 
  取消事务，放弃执行事务块内的所有命令。

bash复制代码EXEC 
  执行所有事务块内的命令。

bash复制代码MULTI 
  标记一个事务块的开始。

bash复制代码UNWATCH 
  取消 WATCH 命令对所有 key 的监视。

bash复制代码WATCH   key [key ...] 
  监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

python复制代码import requests
# 该网址专门用于测试使用
url = 'http://httpbin.org/post'
data = {'key1':'value1','key2':'value2'}
r =requests.post(url,data)
print(r)
print(r.text)
print(r.content)

python复制代码import requests
# 该网址专门用于测试使用
url = 'http://httpbin.org/post'
payload = (('key1', 'value1'), ('key1', 'value2'))
r = requests.post('http://httpbin.org/post', data=payload)

print(r.text)

python复制代码import requests
import json

# 该网址专门用于测试使用
url_json = 'http://httpbin.org/post'
# dumps：将python对象解码为json数据
data_json = json.dumps({'key1': 'value1', 'key2': 'value2'})
r_json = requests.post(url_json, data_json)

print(r_json.text)

python复制代码def get_feed():
	# 拼接数据字典
    data = {
        "last_dateline": "1605591900",
        "platform": "www",
        "is_ai": 0
    }
    r = requests.post(
        "https://moment-api.huxiu.com/web-v2/moment/feed", data=data)
    data = r.json()
    # data["success"]

    # 获取数据,注意嵌套的层次有点多，慢慢对应即可
    datalist = data["data"]["moment_list"]["datalist"][0]["datalist"]
    print(datalist)

python复制代码import requests
headers = {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36"
}

def agree(moment_id):

    data = {
        "moment_id": moment_id,
        "platform": "www",
    }

    r = requests.post(
        "https://moment-api.huxiu.com/web/moment/agree", data=data, headers=headers)
    res_data = r.json()
    print(res_data)
    # print(res_data["success"] == "true")

if __name__ == "__main__":
    agree(130725)

python复制代码{'success': False, 'message': '请开启COOKIE'}

python复制代码def agree(moment_id):
    s = requests.Session()
    r = s.get("https://www-api.huxiu.com/v1/user/checklogin", headers=headers)

    jar = r.cookies
    print(jar.items())
    data = {
        "moment_id": moment_id,
        "platform": "www",
    }

    r = s.post(
        "https://moment-api.huxiu.com/web/moment/agree", data=data, headers=headers, cookies=jar)
    res_data = r.json()
    print(res_data)
    # print(res_data["success"] == "true")

python复制代码{'success': True, 'message': '点赞成功'}

bash复制代码cp conf/alluxio-site.properties.template  alluxio-site.properties#放开注释：alluxio.master.hostname=127.0.0.1alluxio.master.mount.table.root.ufs=${alluxio.work.dir}/underFSStorage

bash复制代码vi conf/mastersvi conf/workers

shell复制代码# mount对应磁盘bin/alluxio-mount.sh Mount workers# 进行环境校验bin/alluxio validateEnv masterbin/alluxio validateEnv worker

css复制代码# 启动所有服务bin/alluxio-start.sh all# 停止所有服务bin/alluxio-stop.sh all# 启动单个服务bin/alluxio-start.sh -a masterbin/alluxio-start.sh -a workerbin/alluxio-start.sh -a job_masterbin/alluxio-start.sh -a job_workerbin/alluxio-start.sh -a proxy

xml复制代码<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.3.4.RELEASE</version>
</parent>

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>Hoxton.RELEASE</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

xml复制代码<dependencies>
  <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  </dependency>
</dependencies>

yaml复制代码server:
  port: 18888

less复制代码@SpringBootApplication
@EnableHystrix
public class ServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class, args);
    }

}

less复制代码@RestController
@RequestMapping("/fallback")
public class FallbackMethodController {

    @GetMapping
    @HystrixCommand(fallbackMethod = "fallback")
    public ResponseEntity<String> demo() {
        // 模拟服务异常
       throw new RuntimeException("Error.");
    }
    
    private ResponseEntity<String> fallback() {
        return new ResponseEntity<>("Hello World!", HttpStatus.OK);
    }

}

less复制代码@RestController
@RequestMapping("/defaultFallback")
// 整体定义后备方法
@DefaultProperties(defaultFallback = "defaultFallback")
public class DefaultFallbackMethodController {

    @GetMapping
    @HystrixCommand
    public ResponseEntity<String> demo() {
        throw new RuntimeException("Error.");
    }

    public ResponseEntity<String> defaultFallback() {
        return new ResponseEntity<>("Hello World.", HttpStatus.OK);
    }
}

less复制代码@RestController
@RequestMapping("/timeout")
public class TimeoutController {

    @GetMapping
    @HystrixCommand(
            fallbackMethod = "fallback",
            commandProperties = {
                    @HystrixProperty(
                            name = "execution.isolation.thread.timeoutInMilliseconds",
                            value = "2000"
                    )
            })
    public ResponseEntity<String> demo() {
        try {
            // 模拟接口请求，时间设置为3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ResponseEntity<>("Hello!", HttpStatus.OK);
    }


    private ResponseEntity<String> fallback() {
        return new ResponseEntity<>("Timeout!", HttpStatus.OK);
    }

}

less复制代码@RestController
@RequestMapping("/closeTimeout")
public class TimeoutDisableController {


    @GetMapping
    @HystrixCommand(
            fallbackMethod = "fallback",
            commandProperties = {
                    @HystrixProperty(
                            name = "execution.timeout.enabled",
                            value = "false"
                    )
            })
    public ResponseEntity<String> demo() {
        try {
            // 模拟接口请求
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ResponseEntity<>("Hello!", HttpStatus.OK);
    }


    private ResponseEntity<String> fallback() {
        return new ResponseEntity<>("Timeout!", HttpStatus.OK);
    }
    
}

less复制代码@RestController
@RequestMapping("/circuitBreaker")
public class CircuitBreakConfigController {


    @GetMapping
    @HystrixCommand(
            fallbackMethod = "fallback",
            commandProperties = {
                    @HystrixProperty(
                            name = "execution.isolation.thread.timeoutInMilliseconds",
                            value = "1000"
                    ),
                    @HystrixProperty(
                            name = "circuitBreaker.requestVolumeThreshold",
                            value = "4"
                    ),
                    @HystrixProperty(
                            name = "circuitBreaker.errorThresholdPercentage",
                            value = "50"
                    ),
                    @HystrixProperty(
                            name = "metrics.rollingStats.timeInMilliseconds",
                            value = "60000"
                    ),
                    @HystrixProperty(
                            name = "circuitBreaker.sleepWindowInMilliseconds",
                            value = "60000"
                    )
            })
    public ResponseEntity<String> demo() {
        try {
            // 模拟接口请求
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ResponseEntity<>("Hello!", HttpStatus.OK);
    }


    private ResponseEntity<String> fallback() {
        return new ResponseEntity<>("Timeout!", HttpStatus.OK);
    }


}

xml复制代码<!--openfeign 中已经依赖了Hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

less复制代码@SpringBootApplication
@EnableFeignClients // 支持Hystrix
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

}

yaml复制代码server:
  port: 19999

# 开启feign对hystrix的支持
feign:
  hystrix:
    enabled: true
  client:
    config:
      default:
        readTimeout: 3000
        connectTimeout: 3000

less复制代码@FeignClient(value = "service", url = "http://localhost:18888/fallback", fallback = ServerClientFallback.class)
public interface ServerClient {

    @GetMapping
    ResponseEntity<String> demo();

}

@Component
class ServerClientFallback implements ServerClient {

    @Override
    public ResponseEntity<String> demo() {
        return new ResponseEntity<>("Client FallBack!", HttpStatus.OK);
    }
}

less复制代码@RestController
@RequestMapping("/feign")
public class FeignController {

    @Autowired
    private ServerClient serverClient;

    @GetMapping
    public ResponseEntity<String> demo() {
        return serverClient.demo();
    }
}

bash复制代码$ vim 文件名 行数 # 查看文件并定位到具体行数

[root@VM-8-10-centos app]# vim --help
VIM - Vi IMproved 8.0 (2016 Sep 12, compiled Jun 18 2020 15:49:08)

usage: vim [arguments] [file ..]       edit specified file(s)
   or: vim [arguments] -               read text from stdin
   or: vim [arguments] -t tag          edit file where tag is defined
   or: vim [arguments] -q [errorfile]  edit file with first error

Arguments:
   --			Only file names after this
   -v			Vi mode (like "vi")
   -e			Ex mode (like "ex")
   -E			Improved Ex mode
   -s			Silent (batch) mode (only for "ex")
   -d			Diff mode (like "vimdiff")
   -y			Easy mode (like "evim", modeless)
   -R			Readonly mode (like "view")
   -Z			Restricted mode (like "rvim")
   -m			Modifications (writing files) not allowed
   -M			Modifications in text not allowed
   -b			Binary mode
   -l			Lisp mode
   -C			Compatible with Vi: 'compatible'

bash复制代码rm -rf a.txt.swp # 删除即可

bash复制代码echo 字符串 # 展示文本
[root@VM-8-10-centos touch-test]# echo "hello world"
hello world

echo 字符串 > 文件名 # 将字符串写到文件中(覆盖文件中的内容)
echo 字符串 >> 文件名 # 将字符串写到文件中(不覆盖文件中内容)
cat 不存在的目录 &>> error.log # 将命令的失败结果 追加到 error.log文件的后面

bash复制代码ln -s 目标文件路径 快捷方式路径

[root@VM-8-10-centos app]# ln --help
Usage: ln [OPTION]... [-T] TARGET LINK_NAME
  or:  ln [OPTION]... TARGET
  or:  ln [OPTION]... TARGET... DIRECTORY
  or:  ln [OPTION]... -t DIRECTORY TARGET...
# 示例
cd app
ln -s /app/command/test test

bash复制代码find --help
Usage: find [-H] [-L] [-P] [-Olevel] [-D help|tree|search|stat|rates|opt|exec] [path...] [expression]

语法: find [参数选项] <指定目录> <指定条件> <指定内容>  # 在指定目录下查找文件
-name filename # 查找名为filename的文件 按文件名查找
-ctime -n或+n # 按时间来查找文件, -n指n天以内, +n指n天以前

[root@VM-8-10-centos app]# find . -name setup
./test/setup
./setup
# 全盘查找
find / -name "*.txt"

kotlin复制代码public void run() {
    log.info(this.getServiceName() + " service started");
    // while循环，服务不停止就一直调用mmapOperation这个方法
    while (!this.isStopped() && this.mmapOperation()) {
​
    }
    log.info(this.getServiceName() + " service end");
}
​
// 此线程不断循环调用的mmapOperation究竟做了什么操作
private boolean mmapOperation() {
    boolean isSuccess = false;
    AllocateRequest req = null;
    try {
      // 从优先队列中获取AllocateRequest
      // 如果requestQueue为空，会阻塞等待唤醒
      req = this.requestQueue.take();
      // 从ConcurrentMap requestTable中获取AllocateRequest
      AllocateRequest expectedRequest = this.requestTable.get(req.getFilePath());
      // 校验
      // requestQueue和requestTable中的数据需一致
      if (null == expectedRequest) {
        log.warn("this mmap request expired, maybe cause timeout " + req.getFilePath() + " "
                 + req.getFileSize());
        return true;
      }
      if (expectedRequest != req) {
        log.warn("never expected here,  maybe cause timeout " + req.getFilePath() + " "
                 + req.getFileSize() + ", req:" + req + ", expectedRequest:" + expectedRequest);
        return true;
      }
      // 如果MappedFile为空，表示要创建MappedFile
      if (req.getMappedFile() == null) {
        // 记录开始创建MappedFile的时间
        long beginTime = System.currentTimeMillis();
​
        MappedFile mappedFile;
        // 判断是否开启isTransientStorePoolEnable，如果开启则使用直接内存写入数据，这个判断有三个条件
        // 1.开启transientStorePoolEnable配置
        // 2.异步输盘
        // 3.必须是Broker主节点
        // transientStorePoolEnable = true 时，mappedByteBuffer 只是用来读消息，堆外内存用来写消息，从而实现对于消息的读写分离
        if (messageStore.getMessageStoreConfig().isTransientStorePoolEnable()) {
          try {
            mappedFile = ServiceLoader.load(MappedFile.class).iterator().next();
            mappedFile.init(req.getFilePath(), req.getFileSize(), messageStore.getTransientStorePool());
          } catch (RuntimeException e) {
            log.warn("Use default implementation.");
            mappedFile = new MappedFile(req.getFilePath(), req.getFileSize(), messageStore.getTransientStorePool());
          }
        } else {
          // 使用 mmap 方式创建MappedFile
          mappedFile = new MappedFile(req.getFilePath(), req.getFileSize());
        }
        // 计算创建MappedFile所用的时间
        long elapsedTime = UtilAll.computeElapsedTimeMilliseconds(beginTime);
        // 如果超过10ms则打印告警日志
        if (elapsedTime > 10) {
          int queueSize = this.requestQueue.size();
          log.warn("create mappedFile spent time(ms) " + elapsedTime + " queue size " + queueSize
                   + " " + req.getFilePath() + " " + req.getFileSize());
        }
        
        // 满足这两个条件会进行文件预热
        // 1.配置了进行文件预热
        // 2.只有 CommitLog 才进行文件预热，所以MappedFile的文件大小需大于CommitLog的文件大小，CommitLog 的大小默认为1G
        // 文件预热会进行数据预写入，根据系统的 pageSize 对每个 pageSize 写入一个字节数据。
        if (mappedFile.getFileSize() >= this.messageStore.getMessageStoreConfig()
            .getMappedFileSizeCommitLog()
            &&
            this.messageStore.getMessageStoreConfig().isWarmMapedFileEnable()) {
          mappedFile.warmMappedFile(this.messageStore.getMessageStoreConfig().getFlushDiskType(),
                                    this.messageStore.getMessageStoreConfig().getFlushLeastPagesWhenWarmMapedFile());
        }
​
        req.setMappedFile(mappedFile);
        this.hasException = false;
        isSuccess = true;
      }
    } 
    ......
    } finally {
      if (req != null && isSuccess)
        req.getCountDownLatch().countDown();
    }
    return true;
}

kotlin复制代码public MappedFile getLastMappedFile(final long startOffset, boolean needCreate) {
    long createOffset = -1;
    // 获取将要写入的CommitLog对应的MappedFile
    MappedFile mappedFileLast = getLastMappedFile();
    // 如果MappedFile为空，表示要进行创建
    if (mappedFileLast == null) {
      // 计算出新文件的起始偏移量（起始偏移量即文件名称）
      createOffset = startOffset - (startOffset % this.mappedFileSize);
    }
    // 如果MappedFile写满了，同样要计算新文件的起始偏移量
    if (mappedFileLast != null && mappedFileLast.isFull()) {
      createOffset = mappedFileLast.getFileFromOffset() + this.mappedFileSize;
    }
​
    if (createOffset != -1 && needCreate) {
      // 拼接文件名称
      String nextFilePath = this.storePath + File.separator + UtilAll.offset2FileName(createOffset);
      String nextNextFilePath = this.storePath + File.separator
        + UtilAll.offset2FileName(createOffset + this.mappedFileSize);
      MappedFile mappedFile = null;
      // allocateMappedFileService 已初始化，创建下一个文件和下下个文件
      if (this.allocateMappedFileService != null) {
        mappedFile = this.allocateMappedFileService.putRequestAndReturnMappedFile(nextFilePath,
                                                                                  nextNextFilePath, this.mappedFileSize);
      } else {
        // allocateMappedFileService 未初始化，直接创建文件
        try {
          mappedFile = new MappedFile(nextFilePath, this.mappedFileSize);
        } catch (IOException e) {
          log.error("create mappedFile exception", e);
        }
      }
      // 将创建的 MappedFile 对象添加到 mappedFiles 列表中
      if (mappedFile != null) {
        if (this.mappedFiles.isEmpty()) {
          mappedFile.setFirstCreateInQueue(true);
        }
        this.mappedFiles.add(mappedFile);
      }
      // 返回新创建的MappedFile
      return mappedFile;
    }
​
    return mappedFileLast;
}

kotlin复制代码public MappedFile putRequestAndReturnMappedFile(String nextFilePath, String nextNextFilePath, int fileSize) {
    // 默认提交两个请求
    int canSubmitRequests = 2;
    if (this.messageStore.getMessageStoreConfig().isTransientStorePoolEnable()) {
      if (this.messageStore.getMessageStoreConfig().isFastFailIfNoBufferInStorePool()
          && BrokerRole.SLAVE != this.messageStore.getMessageStoreConfig().getBrokerRole()) { //if broker is slave, don't fast fail even no buffer in pool
        canSubmitRequests = this.messageStore.getTransientStorePool().availableBufferNums() - this.requestQueue.size();
      }
    }
​
    AllocateRequest nextReq = new AllocateRequest(nextFilePath, fileSize);
    // 向ConcurrentHashMap中存放AllocateRequest对象，如果存放失败说明有别的线程已经创建相同的文件
    boolean nextPutOK = this.requestTable.putIfAbsent(nextFilePath, nextReq) == null;
    // 存放成功，向requestQueue存放AllocateRequest对象
    if (nextPutOK) {
      // 异常处理
      if (canSubmitRequests <= 0) {
        log.warn("[NOTIFYME]TransientStorePool is not enough, so create mapped file error, " +
                 "RequestQueueSize : {}, StorePoolSize: {}", this.requestQueue.size(), this.messageStore.getTransientStorePool().availableBufferNums());
        this.requestTable.remove(nextFilePath);
        return null;
      }
      boolean offerOK = this.requestQueue.offer(nextReq);
      if (!offerOK) {
        log.warn("never expected here, add a request to preallocate queue failed");
      }
      canSubmitRequests--;
    }
    // 相同的逻辑，上面是创建下一个文件，此处是创建下下个文件
    AllocateRequest nextNextReq = new AllocateRequest(nextNextFilePath, fileSize);
    boolean nextNextPutOK = this.requestTable.putIfAbsent(nextNextFilePath, nextNextReq) == null;
    if (nextNextPutOK) {
      if (canSubmitRequests <= 0) {
        log.warn("[NOTIFYME]TransientStorePool is not enough, so skip preallocate mapped file, " +
                 "RequestQueueSize : {}, StorePoolSize: {}", this.requestQueue.size(), this.messageStore.getTransientStorePool().availableBufferNums());
        this.requestTable.remove(nextNextFilePath);
      } else {
        boolean offerOK = this.requestQueue.offer(nextNextReq);
        if (!offerOK) {
          log.warn("never expected here, add a request to preallocate queue failed");
        }
      }
    }
​
    ......
​
    AllocateRequest result = this.requestTable.get(nextFilePath);
    try {
      if (result != null) {
        // 等待下一个MappedFile文件创建完成
        boolean waitOK = result.getCountDownLatch().await(waitTimeOut, TimeUnit.MILLISECONDS);
        if (!waitOK) {
          log.warn("create mmap timeout " + result.getFilePath() + " " + result.getFileSize());
          return null;
        } else {
          // 删除requestTable中对应的数据
          this.requestTable.remove(nextFilePath);
          return result.getMappedFile();
        }
      } else {
        log.error("find preallocate mmap failed, this never happen");
      }
    } catch (InterruptedException e) {
      log.warn(this.getServiceName() + " service has exception. ", e);
    }
​
    return null;
}

kotlin复制代码public AppendMessageResult appendMessagesInner(final MessageExt messageExt, final AppendMessageCallback cb,
            PutMessageContext putMessageContext) {
    assert messageExt != null;
    assert cb != null;
    // 获取消息的写指针
    int currentPos = this.wrotePosition.get();
    // 当前写指针小于文件的大小，那就文件还没写满
    if (currentPos < this.fileSize) {
      // writeBuffer不为空，则取writeBuffer
      // 什么时候writeBuffer不为空呢？
      // 判断的根据为transientStorePoolEnable && FlushDiskType.ASYNC_FLUSH == getFlushDiskType()
      //        && BrokerRole.SLAVE != getBrokerRole();
      // 1.开启transientStorePoolEnable配置
      // 2.异步输盘
      // 3.必须是Broker主节点
      ByteBuffer byteBuffer = writeBuffer != null ? writeBuffer.slice() : this.mappedByteBuffer.slice();
      byteBuffer.position(currentPos);
      AppendMessageResult result;
      // 处理单个消息
      if (messageExt instanceof MessageExtBrokerInner) {
        result = cb.doAppend(this.getFileFromOffset(), byteBuffer, this.fileSize - currentPos,
                             (MessageExtBrokerInner) messageExt, putMessageContext);
        // 处理批量消息
      } else if (messageExt instanceof MessageExtBatch) {
        result = cb.doAppend(this.getFileFromOffset(), byteBuffer, this.fileSize - currentPos,
                             (MessageExtBatch) messageExt, putMessageContext);
      } else {
        return new AppendMessageResult(AppendMessageStatus.UNKNOWN_ERROR);
      }
      // 更新wrotePosition的位置
      this.wrotePosition.addAndGet(result.getWroteBytes());
      this.storeTimestamp = result.getStoreTimestamp();
      return result;
    }
    log.error("MappedFile.appendMessage return null, wrotePosition: {} fileSize: {}", currentPos, this.fileSize);
    return new AppendMessageResult(AppendMessageStatus.UNKNOWN_ERROR);
}

kotlin复制代码public AppendMessageResult doAppend(final long fileFromOffset, final ByteBuffer byteBuffer, final int maxBlank,
            final MessageExtBrokerInner msgInner, PutMessageContext putMessageContext) {
            
​
    ......
​
    // 确认是否有足够的空闲空间
    // 如果超过，返回END_OF_FILE，在此方法的外面会处理这种场景
    // 处理方式是创建一个新的文件存储消息
    if ((msgLen + END_FILE_MIN_BLANK_LENGTH) > maxBlank) {
      this.msgStoreItemMemory.clear();
      this.msgStoreItemMemory.putInt(maxBlank);
      // BLANK_MAGIC_CODE表示一个CommitLog文件结尾魔法值，当设置成这个魔法值表示文件已写完
      this.msgStoreItemMemory.putInt(CommitLog.BLANK_MAGIC_CODE);
      final long beginTimeMills = CommitLog.this.defaultMessageStore.now();
      byteBuffer.put(this.msgStoreItemMemory.array(), 0, 8);
      return new AppendMessageResult(AppendMessageStatus.END_OF_FILE, wroteOffset,
                                     maxBlank,
                                     msgIdSupplier, msgInner.getStoreTimestamp(),
                                     queueOffset, CommitLog.this.defaultMessageStore.now() - beginTimeMills);
    }
​
    ......
    return result;
}

python复制代码#这就是一个class的定义代码：
class hello_class():
    pass

python复制代码class hello_class():
    pass

#输出类信息
print(hello_class)
print(type(hello_class))
#创建类的实例对象
print(hello_class())
print(type(hello_class()))

python复制代码#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/11/15 11:58 下午
# @Author : LeiXueWei
# @CSDN/Juejin/Wechat: 雷学委
# @XueWeiTag: CodingDemo
# @File : __init__.py.py
# @Project : hello


class student(object):
    “”“学委补充一下：__init___ 函数为类的初始化函数，在创建类对象实例的时候这个函数会被调用。”“”
    def __init__(self):
        print("hello, I am student")


class programmer(object):
    def __init__(self):
        print("hello, I am programmer")


class student(object):
    def __init__(self):
        print("hello, I am student")


class programmer(object):
    def __init__(self):
        print("hello, I am programmer")


s1 = student
print(s1)
p1 = programmer
print(p1)
s11 = student
print(s11)
p11 = programmer
print(p11)

print("*" * 16)
# 创建对象
s2 = student()
print(s2)
p2 = programmer()
print(p2)

# 创建对象
s3 = student()
print(s3)
p3 = programmer()
print(p3)

ruby复制代码#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/11/15 11:58 下午
# @Author : LeiXueWei
# @CSDN/Juejin/Wechat: 雷学委
# @XueWeiTag: CodingDemo
# @File : __init__.py.py
# @Project : hello


class student(object):
    def __init__(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def study(self):
        print(f"{self.name} : 好好学习，天天向上！")



s1= student("小白")
print(s1)
print(s1.get_name())
print(s1.study())

s2 = student("学委的学生粉丝:哈哈哈")
print(s2)
print(s2.get_name())
print(s2.study())