如何吃透一个Java项目?(附学习实践)


先说一下自己的情况:就是对着视频敲Java项目,其中遇到的BUG还能解决,但就是每次敲完一个项目,就感觉很空虚,项目里面的知识点感觉懂了但又好像没懂,我应该怎样才能掌握一个项目所用的知识点呢?至少不至于过了一头半个月就想不起来这个项目是什么东西了。

写博客记录?,画思维导图?还是怎么样呢?有没有过来人能给点经验呢?

首先,尝试分析下题主感到空虚、似懂非懂的原因,从问题描述来看原因可能有以下几方面:

▐  目标不清晰

在项目学习之前,是否有认真梳理和思考过,希望通过项目学习到哪些技术、重点需掌握哪些知识点?这些知识点又属于自己技术体系中哪个环节,是需要必须熟练掌握还是了解原理即可?相信只有明确目标之后才有学习侧重点和方向。

▐  学习方法


项目学习过程中,是否有带着问题和思考?比如项目核心需要解决的问题场景、使用了哪些技术方案,为什么需要这些技术,方案选择考虑主要有哪些?系统模块这样分层和实现的好处是?这个方法的实现,性能是否可以进一步优化等等。


如果只是纯粹跟着视频将项目代码机械敲一遍,我认为跟练习打字没任何区别,写出来的代码也是没有灵魂如行尸走肉。我相信只有结合自己的思考和理解,才可能赋予新的灵魂,做到知其然知其所以然,相关知识点也才能真正转化为自己的技术。

▐  复习与应用

纸上得来终觉浅,绝知此事要躬行,相信对编程而言更是如此,唯有实践才能出真知。对项目中学到的相关技术、知识点需要在不同场景反复练习和应用,并对过程中遇到的问题不断总结和反思。

其次,回到题主问题,如何吃透一个Java项目?从个人经验来看,大致可以从以下几方面入手:

▐  项目背景了解

学习之前,先对项目业务背景和技术体系做大致的了解,这点非常重要,一是为了解项目核心要解决问题域,二是知道系统涉及哪些技术体系,这样在学习之前可以有相关技术知识准备,以便更轻松高效学习。另外,学习完之后也可以清楚知道,什么样问题可以使用什么技术、什么方案来解决、如何解决的。

▐  系统设计文档学习

对项目和系统大概了解之后,可以开始对系统设计文档熟悉,建议按照架构文档、概要设计、详细设计方式递进。通过设计文档的学习,可以快速对各系统模块有个框架性认识,知道各系统职责、边界、如何交互、系统核心模型等等。

对于设计文档的学习,切不可走马观花,一定要带着问题和思考。比如项目背景中的核心业务问题,架构师是如何转化成技术落地,方案为什么要这样设计,模型为什么要这样抽象,这样做的好处是什么等等?同时,对不理解的问题做需好笔记,以便后续向老师或其他同事请教或讨论等等。

▐  系统熟悉和代码阅读

通过设计文档的学习,对系统设计有整体了解之后,接下来就可以结合业务场景、相关问题去看代码如何实现了。不过代码阅读,也需要注意方式方法,切不可陷入代码细节,应该自顶向下、分层分模块的阅读,以先整体、后模块、单功能点的方式层层递进。先快速走读整个代码模块逻辑,然后再精读某个类、方法的实现。

代码阅读过程中,建议一边阅读一边整理相关代码模块、流程分支、交互时序,以及类图等,以便更好理解,有些IDE工具也可根据代码自动生成,比如IntelliJ IDEA。

代码阅读除了关注具体功能的实现之外,更重要的是需要关心代码设计上的思路和原理、性能考究、设计模式、以及设计原则的应用等。同样,阅读代码注释也非常重要,在研究一个API或方法实现时,先认真阅读代码注释会让你事半功倍,尽可能不要做从代码中反推逻辑和功能的事情。

最后,对于核心功能代码建议分模块精读,不明白部分可借助代码调试。

然后,对于技术学习这块我给几点个人建议,以供题主参考:

▐  制定学习规划

梳理一份适合自己的技术规划,并制定明确的学习路线和计划,让学习更有方向和重点。同样在视频课程的选择上也会更清晰,知道什么样视频该学、什么不该学,也不容易感到迷茫和空虚。如今网上各种学习资料、视频汗牛充栋,学会如何筛选有效、适合自己的信息非常重要。

▐  思考与练习

对于技术编程,无捷径可言,思考和练习都非常重要,需要不断学习、思考、实践反复操练。从了解、会用、知原理、优化不断演进。结合学习计划,可以给自己制定不同挑战,比如学习spring可以尝试自己实现一个ioc容器等等。另外,工作或学习过程中遇到的问题,也是你快速提升技术能力的一个好方法,也请珍惜你遇到的每个问题的机会。时间允许的话,也请尽可能去帮助别人解答问题,像stackoverflow就是个非常不错的选择,帮助别人的同时提升自己。

▐  分享与交流

保持思考总结的习惯,将学到的技术多与人分享交流,教学相长。多与优秀的程序员一起、多参与优秀的开源项目等。

最后,我再以我们团队Dubbo核心开发@哲良 大神的另一开源框架TransmittableThreadLocal(TTL)为例,来讲解下我们该如何学习和快速掌握一个项目。

  • TransmittableThreadLocal(TTL):(https://github.com/alibaba/transmittable-thread-local)

结合上文所述,首先我会将TTL项目相关文档、issues列表认真阅读一遍,让自己对项目能有个大体的认识,并梳理出项目一些关键信息,比如:

  • 文档(https://github.com/alibaba/transmittable-thread-local#-%E5%8A%9F%E8%83%BD)

  • issues列表(https://github.com/alibaba/transmittable-thread-local/issues)

▐  核心要解决的问题

用于解决「在线程池或线程会被复用情况下,如何解决线程ThreadLocal传值问题」

▐  有哪些典型业务场景

    • 分布式跟踪系统或全链路压测(即链路打标)

    • 日志收集记录系统上下文

    • Session级Cache

    • 应用容器或上层框架跨应用代码给下层SDK传递信息

▐  使用到的技术

有线程、线程池、ThreadLocal、InheritableThreadLocal、并发、线程安全等。

然后,再结合使用文档编写几个测试demo,通过程序代码练习和框架使用,一步步加深对框架的理解。比如我这里首先会拿TTL与原生JDK InheritableThreadLocal进行不同比较,体验两者的核心区别。

public class ThreadLocalTest {


    private static final AtomicInteger ID_SEQ = new AtomicInteger();
    private static final ExecutorService EXECUTOR = Executors.newFixedThreadPool(1, r -> new Thread(r, "TTL-TEST-" + ID_SEQ.getAndIncrement()));


    //
    private static ThreadLocal<String> THREAD_LOCAL = new InheritableThreadLocal<>();


    //⑴ 声明TransmittableThreadLocal类型的ThreadLocal
    //private static ThreadLocal<String> THREAD_LOCAL = new TransmittableThreadLocal<>();
    public static void testThreadLocal() throws InterruptedException {
        try {
            //doSomething()...
            THREAD_LOCAL.set("set-task-init-value");
            //
            Runnable task1 = () -> {
                try {
                    String manTaskCtx = THREAD_LOCAL.get();
                    System.out.println("task1:" + Thread.currentThread() + ", get ctx:" + manTaskCtx);
                    THREAD_LOCAL.set("task1-set-value");
                } finally {
                    THREAD_LOCAL.remove();
                }
            };
            EXECUTOR.submit(task1);


            //doSomething....
            TimeUnit.SECONDS.sleep(3);


            //⑵ 设置期望task2可获取的上下文
            THREAD_LOCAL.set("main-task-value");


            //⑶ task2的异步任务逻辑中期望获取⑵中的上下文
            Runnable task2 = () -> {
                String manTaskCtx = THREAD_LOCAL.get();
                System.out.println("task2:" + Thread.currentThread() + ", get ctx :" + manTaskCtx);
            };
            //⑷ 转换为TransmittableThreadLocal 增强的Runnable
            //task2 = TtlRunnable.get(task2);
            EXECUTOR.submit(task2);
        }finally {
            THREAD_LOCAL.remove();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        testThreadLocal();
    }
}


//InheritableThreadLocal 运行结果:
task1:Thread[TTL-TEST-0,5,main], get ctx:set-task-init-value
task2:Thread[TTL-TEST-0,5,main], get ctx :null
    
//TransmittableThreadLocal 运行结果
task1:Thread[TTL-TEST-0,5,main], get ctx:set-task-init-value
task2:Thread[TTL-TEST-0,5,main], get ctx :main-task-value    
    
    

通过代码运行结果,我们可以直观看到使用JDK原生InheritableThreadLocal,在task2异步任务中是无法正确获取代码⑵处所设置的上下文参数,只有改用TransmittableThreadLocal之后,程序才如我们预期正常获取。

不难发现,由JDK原生ThreadLocal切换到TransmittableThreadLocal,只需要做极少量的代码适配即可。

//private static ThreadLocal<String> THREAD_LOCAL = new InheritableThreadLocal<>();
//⑴ 声明TransmittableThreadLocal类型的ThreadLocal
private static ThreadLocal<String> THREAD_LOCAL = new TransmittableThreadLocal<>();


...
//⑷ 转换为TransmittableThreadLocal 增强的Runnable
task2 = TtlRunnable.get(task2);

相信看到这里我们都会不禁想问,为什么只需要简单的更改两行代码,就可以平滑实现上下文透传?TTL框架背后具体都做了哪些工作,到底是怎么实现的呢?相信你和我一样都会比较好奇,也一定有想立马阅读源码一探究竟的冲动。

不过,通常这个时候,我并不会一头扎进源码,一般都会先做几项准备工作,一是回到设计文档再仔细的阅读下相关实现方案,把关键流程和原理了解清楚;二是把涉及到的技术体相关的基础知识再复习或学习一遍,以避免由于一些基础知识原理的不了解,导致源码无法深入研究或花费大量精力。像这里如果我对Thread、ThreadLocal、InheritableThreadLocal、线程池等相关知识不熟悉的话,一定会把相关知识先学习一遍,比如ThreadLocal基本原理、底层数据结构、InheritableThreadLocal如何实现父子线程传递等等。

假设这里你对这些知识都已掌握,如果不熟悉,网上相关介绍文章也早已是汗牛充栋,你搜索学习下即可。这里我们先带着到底如何实现的这个疑问,一起来探究下核心源码实现。

首先把源码clone下来导入IDE,然后结合文档把系统工程结构和各功能模块职责快速熟悉一遍,然后结合文档和Demo找到关键接口和实现类,利用IDE把相关类图结构生成出来,以便快速理解类之间关系。非常不错,TTL整体代码非常精练、命名和包信息描述也都非常规范和清晰,我们可以快速圈出来。

从类图中我们可以清晰看到核心关键类TransmittableThreadLocal是从ThreadLocal继承而来,这样的好处是不破坏ThreadLocal原生能力的同时还可增强和扩展自有能力,也可保证业务代码原有互操作性和最小改动。

然后结合Demo代码,我们不难发现使用TTL主要有三个步骤,TransmittableThreadLocal声明、set、remove方法的调用。根据整个使用流程和方法调用栈,我们也可以很方便梳理出整个代码处理初始化、调用时序。

(这里借用官方原图)

通过流程图,我们可以清晰看到TTL核心流程和原理是通过TransmittableThreadLocal.Transmitter 抓取当前线程的所有TTL值并在其他线程进行回放,然后在回放线程执行完业务操作后,再恢复为回放线程原来的TTL值。

TransmittableThreadLocal.Transmitter提供了所有TTL值的抓取、回放和恢复方法(即CRR操作): 

capture方法:抓取线程(线程A)的所有TTL值。 

replay方法:在另一个线程(线程B)中,回放在capture方法中抓取的TTL值,并返回 回放前TTL值的备份 

restore方法:恢复线程B执行replay方法之前的TTL值(即备份)

弄明白核心流程和原理后,我们现在来分析下相关核心代码,在声明TransmittableThreadLocal变量时,我们会发现框架初始化了一个类级别的变量holder用于存储用户设置的所有ttl上下文,也是为了后续执行capture抓取时使用。

    // Note about the holder:
    // 1. holder self is a InheritableThreadLocal(a *ThreadLocal*).
    // 2. The type of value in the holder is WeakHashMap<TransmittableThreadLocal<Object>, ?>.
    //    2.1 but the WeakHashMap is used as a *Set*:
    //        the value of WeakHashMap is *always* null, and never used.
    //    2.2 WeakHashMap support *null* value.
    private static final InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>> holder =
        new InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>>() {
        @Override
        protected WeakHashMap<TransmittableThreadLocal<Object>, ?> initialValue() {
            return new WeakHashMap<TransmittableThreadLocal<Object>, Object>();
        }
        @Override
        protected WeakHashMap<TransmittableThreadLocal<Object>, ?> childValue(WeakHashMap<TransmittableThreadLocal<Object>, ?> parentValue) {
            return new WeakHashMap<TransmittableThreadLocal<Object>, Object>(parentValue);
        }
    };


    /**
     * see {@link InheritableThreadLocal#set}
     */
    @Override
    public final void set(T value) {
        if (!disableIgnoreNullValueSemantics && null == value) {
            // may set null to remove value
            remove();
        } else {
            super.set(value);
            addThisToHolder();
        }
    }


    private void addThisToHolder() {
        if (!holder.get().containsKey(this)) {
            holder.get().put((TransmittableThreadLocal<Object>) this, null); // WeakHashMap supports null value.
        }
    }

结合set方法实现来看,我们会发现holder变量设计的非常巧妙,业务设置的上下文value部分继续复用ThreadLocal原有数据结构ThreadLocalMap来存储( super.set(value));capture的数据源利用holder进行引用存储(addThisToHolder put this)。这样的好处是既可保持ThreadLocal数据存储原有的封装性,又很好实现扩展。除此之外,holder还有其他设计考究,这里抛出来大家可以思考下:

  1. 为什么holder需要设计成static final类级别变量?

  2. ttl变量的存储为什么需要使用WeakHashMap,而不是hashmap或其他?

然后我们再来看异步task转换 TtlRunnable.get(task2) 核心代码实现,代码整体实现相对比较简单,get方法是一个静态工厂方法,主要作用是将业务传入的普通Runnable task装饰成TtlRunable类,并在TtlRunable构造方法中进行线程capture动作(具体实现我们后面再分析),然后将结果存储到对象属性capturedRef中。

  @Nullable
    public static TtlRunnable get(@Nullable Runnable runnable, boolean releaseTtlValueReferenceAfterRun, boolean idempotent) {
        if (null == runnable) return null;


        if (runnable instanceof TtlEnhanced) {
            // avoid redundant decoration, and ensure idempotency
            if (idempotent) return (TtlRunnable) runnable;
            else throw new IllegalStateException("Already TtlRunnable!");
        }
        //将入参runnable进行了装饰
        return new TtlRunnable(runnable, releaseTtlValueReferenceAfterRun);
    }
  
//......
public final class TtlRunnable implements Runnable, TtlWrapper<Runnable>, TtlEnhanced, TtlAttachments {
    private final AtomicReference<Object> capturedRef;
    private final Runnable runnable;
    private final boolean releaseTtlValueReferenceAfterRun;


    private TtlRunnable(@NonNull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
        this.capturedRef = new AtomicReference<Object>(capture());
        this.runnable = runnable;
        this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
    }


    /**
     * wrap method {@link Runnable#run()}.
     */
    @Override
    public void run() {
        final Object captured = capturedRef.get();
        if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
            throw new IllegalStateException("TTL value reference is released after run!");
        }


        final Object backup = replay(captured);
        try {
            runnable.run();
        } finally {
            restore(backup);
        }
    } 


  //........   
 }

然后是run方法,这也是核心关键的CRR操作了。这里通过模板方法将CRR操作编排在业务逻辑执行的前后了,也即业务逻辑执行前会将capturer的值进行replay恢复,执行后进行复原restore操作。同样这里也有几个问题很值我们思考:

  1. capture操作为什么需要放到TtlRunnable构造方法中,而不能在run方法中?

  2. 代码中使用了哪两个设计模式,使用设计模式的好处是什么?

  3. 业务执行完之后为什么还需要restore操作?

接下来,我们再分别对capture、replay、restore方法实现做个一一分析。首先是capture方法,我们可以看到capture操作整体比较简单,主要是将set操作保存到holder变量中的值进行遍历并以Snapshot结构进行存储返回。

 /**
         * Capture all {@link TransmittableThreadLocal} and registered {@link ThreadLocal} values in the current thread.
         *
         * @return the captured {@link TransmittableThreadLocal} values
         * @since 2.3.0
         */
        @NonNull
        public static Object capture() {
            return new Snapshot(captureTtlValues(), captureThreadLocalValues());
        }


        private static HashMap<TransmittableThreadLocal<Object>, Object> captureTtlValues() {
            HashMap<TransmittableThreadLocal<Object>, Object> ttl2Value = new HashMap<TransmittableThreadLocal<Object>, Object>();
            for (TransmittableThreadLocal<Object> threadLocal : holder.get().keySet()) {
                ttl2Value.put(threadLocal, threadLocal.copyValue());
            }
            return ttl2Value;
        }


        private static HashMap<ThreadLocal<Object>, Object> captureThreadLocalValues() {
            final HashMap<ThreadLocal<Object>, Object> threadLocal2Value = new HashMap<ThreadLocal<Object>, Object>();
            for (Map.Entry<ThreadLocal<Object>, TtlCopier<Object>> entry : threadLocalHolder.entrySet()) {
                final ThreadLocal<Object> threadLocal = entry.getKey();
                final TtlCopier<Object> copier = entry.getValue();


                threadLocal2Value.put(threadLocal, copier.copy(threadLocal.get()));
            }
            return threadLocal2Value;
        }

另一个captureThreadLocalValues,主要是用于将一些已有ThreadLocal中的上下文一起复制,已有ThreadLocal需要通过registerThreadLocal方法来单独注册。相关代码如下:

public static class Transmitter {
    //....
    
  private static volatile WeakHashMap<ThreadLocal<Object>, TtlCopier<Object>> threadLocalHolder = new WeakHashMap<ThreadLocal<Object>, TtlCopier<Object>>();
  private static final Object threadLocalHolderUpdateLock = new Object();


    //......
    public static <T> boolean registerThreadLocal(@NonNull ThreadLocal<T> threadLocal, @NonNull TtlCopier<T> copier, boolean force) {
        if (threadLocal instanceof TransmittableThreadLocal) {
            logger.warning("register a TransmittableThreadLocal instance, this is unnecessary!");
            return true;
        }


        synchronized (threadLocalHolderUpdateLock) {
            if (!force && threadLocalHolder.containsKey(threadLocal)) return false;


            WeakHashMap<ThreadLocal<Object>, TtlCopier<Object>> newHolder = new WeakHashMap<ThreadLocal<Object>, TtlCopier<Object>>(threadLocalHolder);
            newHolder.put((ThreadLocal<Object>) threadLocal, (TtlCopier<Object>) copier);
            threadLocalHolder = newHolder;
            return true;
        }
    }
    //......
}

这里代码有个非常关键的处理,由于WeakHashMap非线程安全,为了避免并发问题安全加上了synchronized锁操作。这里有可以思考下除了synchronized关键字还有什么保障线程安全的方法。另外,实现threadLocal注册时为已经在锁块中了,为什么还要做new copy重新替换操作,这样做目的是什么?大家可以想想看。

最后就是replay和restore方法,整体实现逻辑非常清晰,主要是将captured的值在当前线程ThreadLocal中进行重新赋值初始化,以及业务执行后恢复到原来。这里很佩服作者对不同情况的细致考虑,不是直接将当前holder中的上下文直接备份,而是与之前已capture的内容比较,将业务后set的上下文进行剔除,以免在恢复restore时出现前后不一致的情况。

@NonNull
public static Object replay(@NonNull Object captured) {
    final Snapshot capturedSnapshot = (Snapshot) captured;
    return new Snapshot(replayTtlValues(capturedSnapshot.ttl2Value), replayThreadLocalValues(capturedSnapshot.threadLocal2Value));
}


@NonNull
private static HashMap<TransmittableThreadLocal<Object>, Object> replayTtlValues(@NonNull HashMap<TransmittableThreadLocal<Object>, Object> captured) {
    HashMap<TransmittableThreadLocal<Object>, Object> backup = new HashMap<TransmittableThreadLocal<Object>, Object>();


    for (final Iterator<TransmittableThreadLocal<Object>> iterator = holder.get().keySet().iterator(); iterator.hasNext(); ) {
        TransmittableThreadLocal<Object> threadLocal = iterator.next();


        // backup
        backup.put(threadLocal, threadLocal.get());


        // clear the TTL values that is not in captured
        // avoid the extra TTL values after replay when run task
        if (!captured.containsKey(threadLocal)) {
            iterator.remove();
            threadLocal.superRemove();
        }
    }


    // set TTL values to captured
    setTtlValuesTo(captured);


    // call beforeExecute callback
    doExecuteCallback(true);


    return backup;
}


private static void setTtlValuesTo(@NonNull HashMap<TransmittableThreadLocal<Object>, Object> ttlValues) {
    for (Map.Entry<TransmittableThreadLocal<Object>, Object> entry : ttlValues.entrySet()) {
        TransmittableThreadLocal<Object> threadLocal = entry.getKey();
        threadLocal.set(entry.getValue());
    }
}


public static void restore(@NonNull Object backup) {
    final Snapshot backupSnapshot = (Snapshot) backup;
    restoreTtlValues(backupSnapshot.ttl2Value);
    restoreThreadLocalValues(backupSnapshot.threadLocal2Value);
}


private static void restoreTtlValues(@NonNull HashMap<TransmittableThreadLocal<Object>, Object> backup) {
    // call afterExecute callback
    doExecuteCallback(false);


    for (final Iterator<TransmittableThreadLocal<Object>> iterator = holder.get().keySet().iterator(); iterator.hasNext(); ) {
        TransmittableThreadLocal<Object> threadLocal = iterator.next();


        // clear the TTL values that is not in backup
        // avoid the extra TTL values after restore
        if (!backup.containsKey(threadLocal)) {
            iterator.remove();
            threadLocal.superRemove();
        }
    }


    // restore TTL values
    setTtlValuesTo(backup);
}

核心代码分析完之后,再来简单总结下项目中学习到的知识点:

  1. 对ThreadLocal、InheritableThreadLocal有了更加系统和深入的理解,包括两者继承关系、底层数据结构ThreadLocalMap与Thread关联关系等。

  2. 面向gc编程(gc相关)、WeakHashMap(Java对象引用类型强、软、弱等)、线程安全、并发等等

  3. 设计模式相关,装饰模式、工厂、模板方法、代理等

  4. TTL虽然代码量不算多,但短小精悍,也处处体现了作者超高的设计和编程能力,每行代码都值得学习和反复琢磨。

我相信通过类似这样的一个项目学习流程下来,把每个环节都能踏踏实实做好,且过程中有贯穿自己思考和理解。相信你一定能把每个项目吃透,并把项目中的每个技术点都牢牢掌握。

最后,我所在团队是淘系技术部淘系架构团队,主要在负责一站式serverless研发平台建设,为业务不断提升研发效率和极致体验。平台已平稳支撑淘系互动、淘宝人生、金币庄园、特价版、闲鱼、拍卖、品牌轻店等多个业务的6.18、双11、双12、春晚等多个大促活动。


  阿里巴巴集团淘系技术部招聘啦~  

欢迎加入淘系架构团队,团队成员大牛云集,有阿里移动中间件的创始人员、Dubbo核心成员、更有一群热爱技术,期望用技术推动业务的小伙伴。

淘系架构团队,推进淘系(淘宝、天猫等)架构升级,致力于为淘系、整个集团提供基础核心能力、产品与解决方案:

  • 业务高可用的解决方案与核心能力(精细化流量管控Marconi平台:为业务提供自适应流控、隔离与熔断的柔性高可用解决方案,站点高可用:故障自愈、多机房与异地容灾与快速切流恢复

  • 一站式serverless研发平台GAIA,为业务提供高效研发效率和极致体验。

  • 下一代网络协议QUIC实现与落地

  • 移动中间件(API网关MTop、接入层AServer、消息/推送、配置中心等等)

期待一起参与加入淘系基础平台的建设~

简历投递至少千???? :zhiheng.gao@alibaba-inc.com

✿  拓展阅读

作者|少千

编辑|橙子君

出品|阿里巴巴新零售淘系技术

已标记关键词 清除标记
相关推荐