1.【Poco笔记】线程Thread
2.老生常谈线程基础的源码几个问题
3.直播带货源码，异步处理中会处理两次请求

【Poco笔记】线程Thread

        Poco的Thread是对标准库std::thread的封装，同时它类似Java一样，提供了Runnable接口。所以使用上是对标Java的。

        与标准库不同的是，Poco::Thread创建和运行时相分离的。这一点标准库设计确实不太友好。例如下面例子。

        同样看例子

        由上面可见，使用基本跟Java类似。创建与运行也分离了。

        看一下主要的运行接口，摘自Poco1.9源码

        源码文件主要包含

        1.Thread.h/Thread.cpp

        提供外部调用接口

        在Thread.cpp中定义了两种Holder,源码 RunnableHolder和CallableHolder。Holder技术是Poco框架中经常用到的，是对某一种类型对象的指针包装。

        Runnable为线程运行类的基类，

        Callable为带一个参数的方法

        2.Thread_POSIX.h/Thread_POSIX.cpp

        3.Thread_VX.h/Thread_VX.cpp

        4.Thread_WIN.h/Thread_WIN.cpp

        5.Thread_WINCE.h/Thread_WINCE.cpp

        这几个文件，每个文件中都定义了ThreadImpl，用于不同平台下的具体实现，Thread私有继承ThreadImp，ThreadImp用于哪一个文件由编译宏决定。

        顺便说一下POSIX系统下的实现。因为使用的是c++，当时没有thread类，所以所有的实现都是使用pthread库来实现的。具体的使用请参考pthread技术文档。

        6.ThreadLocal.h/ThreadLocal.cpp

        ThreadLocal中定义了三个类， TLSAbstractSlot类， TLSSlot类， ThreadLocalStorageç±»

        TLSAbstractSlot是基类，TLSSlot是模板类，通过模板技术包裹了具体的类型。ThreadLocalStorage是用于线程存储，具体是通过一个map来实现。

        因为1.9使用的是c++，还没有引用local_thread关键字，所以这里是通过这种方式实现。

        ThreadLocalStorage定义如下

        那么Poco::Thread的tls是如何定义的？

        源码文件比较少，主要如下文件

        1.Thread.h/Thread.cpp

        2.Thread_STD.h/Thread_POSIX.cpp/Thread_VX.cpp/Thread_WIN.cpp

        Thread.h 主要对实现类ThreadImp的包装，并定义了对外接口。

        Thread_STD.h定义了内部实现,主要提供了ThreadImpç±»

        Thread_POSIX.cpp/Thread_VX.cpp/Thread_WIN.cpp分别定义不同平台下的兼容实现

        在Thread_STD.h中定义了几个重要类型

        在Thread.cpp中增加了两种

        private修饰的ThreadData，定义了线程内部数据。 1.9中源码分别定义在各个平台实现类中，这里抽离出来定义在Thread.cpp中。较之前的定义，这里额外的是新增了std::thread指针。因为直接引用了c++中的thread，有些实现直接借助于它。

老生常谈线程基础的几个问题

       实现线程只有一种方式

       我们知道启动线程至少可以通过以下四种方式：

       实现Runnable接口

       继承Thread类

       线程池创建线程

       带返回值的Callable创建线程

       但是看它们的底层就一种方式，就是源码通过newThread()实现，其他的源码只不过在它的上面做了层封装。

       实现Runnable接口要比继承Thread类的源码更好：

       结构上分工更明确，线程本身属性和任务逻辑解耦。源码租房带源码的模式

       某些情况下性能更好，源码直接把任务交给线程池执行，源码无需再次newThread()。源码

       可拓展性更好：实现接口可以多个，源码而继承只能单继承。源码

       有的源码时候可能会问到启动线程为什么是start()方法，而不是源码run()方法，这个问题很简单，源码执行run()方法其实就是源码在执行一个类的普通方法，并没有启动一个线程，而start()方法点进去看是一个native方法。

       当我们在执行java中的start()方法的时候，它的底层会调JVM由c++编写的代码Thread::start，然后c++代码再调操作系统的create_thread创建线程，创建完线程以后并不会马上运行，要等待CPU的调度。CPU的幂律分布源码调度算法有很多，比如先来先服务调度算法（FIFO），最短优先（就是对短作业的优先调度）、时间片轮转调度等。如下图所示：

线程的状态

       在Java中线程的生命周期中一共有6种状态。

       NEW：初始状态，线程被构建，但是还没有调用start方法

       RUNNABLE：运行状态，JAVA线程把操作系统中的就绪和运行两种状态统一称为运行中

       BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了CPU使用权

       WAITING:等待状态

       TIMED_WAITING：超时等待状态，超时以后自动返回

       TERMINATED：终止状态，表示当前线程执行完毕

       当然这也不是我说的，源码中就是这么定义的：

publicenumState{ /***Threadstateforathreadwhichhasnotyetstarted.*/NEW,/***Threadstateforarunnablethread.Athreadintherunnable*stateisexecutingintheJavavirtualmachinebutitmay*bewaitingforotherresourcesfromtheoperatingsystem*suchasprocessor.*/RUNNABLE,/***Threadstateforathreadblockedwaitingforamonitorlock.*Athreadintheblockedstateiswaitingforamonitorlock*toenterasynchronizedblock/methodor*reenterasynchronizedblock/methodaftercalling*{ @linkObject#wait()Object.wait}.*/BLOCKED,/***Threadstateforawaitingthread.*Athreadisinthewaitingstateduetocallingoneofthe*followingmethods:*<ul>*<li>{ @linkObject#wait()Object.wait}withnotimeout</li>*<li>{ @link#join()Thread.join}withnotimeout</li>*<li>{ @linkLockSupport#park()LockSupport.park}</li>*</ul>**<p>Athreadinthewaitingstateiswaitingforanotherthreadto*performaparticularaction.**Forexample,athreadthathascalled<tt>Object.wait()</tt>*onanobjectiswaitingforanotherthreadtocall*<tt>Object.notify()</tt>or<tt>Object.notifyAll()</tt>on*thatobject.Athreadthathascalled<tt>Thread.join()</tt>*iswaitingforaspecifiedthreadtoterminate.*/WAITING,/***Threadstateforawaitingthreadwithaspecifiedwaitingtime.*Athreadisinthetimedwaitingstateduetocallingoneof*thefollowingmethodswithaspecifiedpositivewaitingtime:*<ul>*<li>{ @link#sleepThread.sleep}</li>*<li>{ @linkObject#wait(long)Object.wait}withtimeout</li>*<li>{ @link#join(long)Thread.join}withtimeout</li>*<li>{ @linkLockSupport#parkNanosLockSupport.parkNanos}</li>*<li>{ @linkLockSupport#parkUntilLockSupport.parkUntil}</li>*</ul>*/TIMED_WAITING,/***Threadstateforaterminatedthread.*Thethreadhascompletedexecution.*/TERMINATED;}

       下面是这六种状态的转换：

New新创建

       New表示线程被创建但尚未启动的状态：当我们用newThread()新建一个线程时，如果线程没有开始调用start()方法，那么此时它的状态就是New。而一旦线程调用了start()，它的状态就会从New变成Runnable。

Runnable运行状态

       Java中的Runable状态对应操作系统线程状态中的两种状态，分别是Running和Ready，也就是说，Java中处于Runnable状态的线程有可能正在执行，也有可能没有正在执行，正在等待被分配CPU资源。mathf.lerp源码

       如果一个正在运行的线程是Runnable状态，当它运行到任务的一半时，执行该线程的CPU被调度去做其他事情，导致该线程暂时不运行，它的状态依然不变，还是Runnable，因为它有可能随时被调度回来继续执行任务。

       在Java中Blocked、Waiting、TimedWaiting，这三种状态统称为阻塞状态，下面分别来看下。

Blocked

       从上图可以看出，从Runnable状态进入Blocked状态只有一种可能，就是进入synchronized保护的代码时没有抢到monitor锁，jvm会把当前的线程放入到锁池中。当处于Blocked的线程抢到monitor锁，就会从Blocked状态回到Runnable状态。

Waiting状态

       我们看上图，线程进入Waiting状态有三种可能。

       没有设置Timeout参数的Object.wait()方法，jvm会把当前线程放入到等待队列。主力 辅助指标源码

       没有设置Timeout参数的Thread.join()方法。

       LockSupport.park()方法。

       Blocked与Waiting的区别是Blocked在等待其他线程释放monitor锁，而Waiting则是在等待某个条件，比如join的线程执行完毕，或者是notify()/notifyAll()。

       当执行了LockSupport.unpark()，或者join的线程运行结束，或者被中断时可以进入Runnable状态。当调用notify()或notifyAll()来唤醒它，它会直接进入Blocked状态，因为唤醒Waiting状态的线程能够调用notify()或notifyAll()，肯定是已经持有了monitor锁，这时候处于Waiting状态的线程没有拿到monitor锁，就会进入Blocked状态，直到执行了notify()/notifyAll()唤醒它的线程执行完毕并释放monitor锁，才可能轮到它去抢夺这把锁，如果它能抢到，就会从Blocked状态回到Runnable状态。

TimedWaiting状态

       在Waiting上面是TimedWaiting状态，这两个状态是非常相似的，区别仅在于有没有时间限制，spring源码工厂模式TimedWaiting会等待超时，由系统自动唤醒，或者在超时前被唤醒信号唤醒。

       以下情况会让线程进入TimedWaiting状态。

       设置了时间参数的Thread.sleep(longmillis)方法。

       设置了时间参数的Object.wait(longtimeout)方法。

       设置了时间参数的Thread.join(longmillis)方法。

       设置了时间参数的LockSupport.parkNanos(longnanos)。

       LockSupport.parkUntil(longdeadline)方法。

       在TimedWaiting中执行notify()和notifyAll()也是一样的道理，它们会先进入Blocked状态，然后抢夺锁成功后，再回到Runnable状态。当然，如果它的超时时间到了且能直接获取到锁/join的线程运行结束/被中断/调用了LockSupport.unpark()，会直接恢复到Runnable状态，而无需经历Blocked状态。

Terminated终止

       Terminated终止状态，要想进入这个状态有两种可能。

       run()方法执行完毕，线程正常退出。

       出现一个没有捕获的异常，终止了run()方法，最终导致意外终止。

线程的停止interrupt

       我们知道Thread提供了线程的一些操作方法，比如stop()，suspend()和resume()，这些方法已经被Java直接标记为@Deprecated，这就说明这些方法是不建议大家使用的。

       因为stop()会直接把线程停止，这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑，任务戛然而止，会导致出现数据完整性等问题。这种行为类似于在linux系统中执行kill-9类似，它是一种不安全的操作。

       而对于suspend()和resume()而言，它们的问题在于如果线程调用suspend()，它并不会释放锁，就开始进入休眠，但此时有可能仍持有锁，这样就容易导致死锁问题，因为这把锁在线程被resume()之前，是不会被释放的。

interrupt

       最正确的停止线程的方式是使用interrupt，但interrupt仅仅起到通知被停止线程的作用。而对于被停止的线程而言，它拥有完全的自主权，它既可以选择立即停止，也可以选择一段时间后停止，也可以选择压根不停止。

       下面我们来看下例子：

publicclassInterruptExampleimplementsRunnable{ //interrupt相当于定义一个volatile的变量//volatilebooleanflag=false;publicstaticvoidmain(String[]args)throwsInterruptedException{ Threadt1=newThread(newInterruptExample());t1.start();Thread.sleep(5);//Main线程来决定t1线程的停止，发送一个中断信号,中断标记变为truet1.interrupt();}@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ System.out.println(Thread.currentThread().getName()+"--");}}}

       执行一下，运行了一会就停止了

       主线程在调用t1的interrupt()之后，这个线程的中断标记位就会被设置成true。每个线程都有这样的标记位，当线程执行时，会定期检查这个标记位，如果标记位被设置成true，就说明有程序想终止该线程。在while循环体判断语句中，通过Thread.currentThread().isInterrupt()判断线程是否被中断，如果被置为true了，则跳出循环，线程就结束了，这个就是interrupt的简单用法。

阻塞状态下的线程中断

       下面来看第二个例子，在循环中加了Thread.sleep秒。

publicclassInterruptSleepExampleimplementsRunnable{ //interrupt相当于定义一个volatile的变量//volatilebooleanflag=false;publicstaticvoidmain(String[]args)throwsInterruptedException{ Threadt1=newThread(newInterruptSleepExample());t1.start();Thread.sleep(5);//Main线程来决定t1线程的停止，发送一个中断信号,中断标记变为truet1.interrupt();}@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ try{ Thread.sleep();}catch(InterruptedExceptione){ //中断标记变为falsee.printStackTrace();}System.out.println(Thread.currentThread().getName()+"--");}}}

       再来看下运行结果，卡主了，并没有停止。这是因为main线程调用了t1.interrupt()，此时t1正在sleep中，这时候是接收不到中断信号的，要sleep结束以后才能收到。这样的中断太不及时了，我让你中断了，你缺还在傻傻的sleep中。

       Java开发的设计者已经考虑到了这一点，sleep、wait等方法可以让线程进入阻塞的方法使线程休眠了，而处于休眠中的线程被中断，那么线程是可以感受到中断信号的，并且会抛出一个InterruptedException异常，同时清除中断信号，将中断标记位设置成false。

       这时候有几种做法：

       直接捕获异常，不做处理，e.printStackTrace();打印下信息

       将异常往外抛出，即在方法上throwsInterruptedException

       再次中断，代码如下，加上Thread.currentThread().interrupt();

@Overridepublicvoidrun(){ while(!Thread.currentThread().isInterrupted()){ try{ Thread.sleep();}catch(InterruptedExceptione){ //中断标记变为falsee.printStackTrace();//把中断标记修改为trueThread.currentThread().interrupt();}System.out.println(Thread.currentThread().getName()+"--");}}

       这时候线程感受到了，我们人为的再把中断标记修改为true，线程就能停止了。一般情况下我们操作线程很少会用到interrupt，因为大多数情况下我们用的是线程池，线程池已经帮我封装好了，但是这方面的知识还是需要掌握的。感谢收看，多多点赞~

       作者：小杰博士

直播带货源码，异步处理中会处理两次请求

       直播带货源码，在异步处理中会处理两次请求，这是从序列图上观察到的SpringMVC处理异步请求的方式。让我们详细解析处理过程：

       HandlerAdapter的处理流程中，异步请求处理有两大环节。首先，处理第一次请求，即异步请求的开始阶段。

       在invokeHandleMethod()方法的处理流程中，除了最终直接返回null的操作外，其余步骤与正常流程相同。在SpringMVC中，异步方法仅需返回值是一个Callable对象，因此参数解析与正常流程一致，不同之处在于返回值的解析流程。让我们深入探讨返回值处理的具体过程。

       在异步请求执行完毕后，进行第二次请求处理。这一阶段，异步操作完成，系统将处理结果返回给客户端。

       通过以上解析，我们了解到直播带货源码在异步处理中会处理两次请求的基本原理。希望本文能为您的理解提供帮助，期待后续文章的深入探讨，敬请关注。