How can one write code to block (wait) on multiple syncro events at once, in a multi-threaded application? We are of course, talking about Delphi. By “multiple synchro events at once”, I mean that the thread unblocks on some logical combination of the statuses of the member events. Here I use the word “event” in a very general sense, not to be confused with the more specific sense of the word event, as in Embarcadero’s “TEvent”. In the general sense, by “event” or “synchro event”, I mean the broad class of synchro objects like semaphore (TSemaphore) and event (TEvent).<\/p>\n
The typical and most common logical combination is the “OR” operation. In other words, how can we block on multiple synchro events and be unblocked when the first event is signaled, or a time-out occurs. When we are finally unblocked, how can we know which event was the signaled one?<\/p>\n
Write some re-usable library code, in Delphi XE7+, to block on multiple synchro events at once, with time-out. The code must be:<\/p>\n
The wait function should allow for optional time-out, detect which entity caused the signal, and should leverage operating system capabilities for optimal efficiency.<\/p>\n
In this post, I will focus a particular subset of this task, where:<\/p>\n
However, I will also address, in less detail, the more general task.<\/p>\n
One of the big bug-bears in multi-threaded programming is that if a thread is blocked on some semaphore for normal operational purposes, then it can’t check if it is time to gracefully shut-down until it is unblocked. Unblocking driven by the semaphore being signaled. But if it is time to gracefully shutdown, then it is quiet likely that the semaphore, in which it is blocked on will never again be signaled, precisely because it is time to shut-down. For this reason, a lot of multi-threaded applications (whether written in Delphi or not) have problems shutting down gracefully. I call this the “block-and-check-terminate” problem. Some readers may be quick to respond, that this is a non-issue. With “proper” design, your programs will never have a “block-and-check-terminate” problem. While this may well be true, in my experience, I have found that in real applications, designing to avoid “block-and-check-terminate” problems, without a generic soltion, is complex and tedious.<\/p>\n
What is needed, is a generic cross-platform solution.<\/p>\n
The Jedi Component Library, in it’s multi-thread component code, provided a wrapper for thread and semaphore. It associated a special semaphore with each thread. The thread semaphore would start life as unsignaled. A call to terminate the thread would cause the special semaphore to be signaled. Whenever the thread would wait on some regular semaphore, the wrap would be defined in such a way that it would call the windows WaitForMultipleObjects()<\/a> function on two semaphores: the explicit semaphore, and the thread’s special semaphore. If the thread was terminated while it was blocked on some operational semaphore, the thread would unblock, detect the condition and properly handle it.<\/p>\n It was a elegant solution to the most common subset of our task. The problem is though, that it only works for Windows. Android, iOS and OSX have no o\/s API equivalent to WaitForMultipleObjects(). I don’t know why. Maybe mobile applications just have less need for within-app parallelism? If you search StackOverflow, there are more than a few questions asking how to wait on multiple semaphores, on Android or iOS, and there are no real solutions given. This is just my opinion. If you disagree, please post a comment below. <\/p>\n I’ve seen this done. When the program needs to shut-down, it just kills its non-main threads with an explicit kill command. Any self-respecting developer will be very uncomfortable with the solution, and it’s degree of safety is very situational.<\/p>\n Design around the issue, so that no thread ever has to wait on multiple conditions. Good luck with that.<\/p>\n Use a threading library, like OTL<\/a>, to provide sufficient higher level structures to support parallel tasking, that there is no design need for lower level structures such as semaphores and events. You could do this, but it is a bit limiting. I think even with OTL, you will still run into requirements where you need to wait on multiple semaphores.<\/p>\n This SO post<\/a>, suggests using a TCountdownEvent object (SyncObjs unit). When either of the component semaphores is signaled, also signal the count-down latch. To wait on the first of either, wait on the latch. The limitations of this solution are: The solution that I offer has a story that goes like this …<\/p>\n Take the synchro classes that you want to use (TSemaphore, TEvent etc), and wrap them so that you take control of their WaitFor() and Signal() methods.<\/p>\n Imagine a new object, called a “Condition”. A condition is a syncro object which is a composite view of an arbitrary set of member synchro objects. This is the Composite Pattern<\/a> applied to synchro objects. The condition is considered signaled according to some rule of your design, based on the signal status of the members. For example, it could be deemed signaled, when one or more members are signaled, but clear when all members are clear. Apply a rule, that you cant directly signal the condition, because that would be meaningless.<\/p>\n The condition is implemented by a private semaphore. When a member semaphore is signaled, the aforementioned condition semaphore is signaled (or not, if you have a different composition rule). When a member semaphore is successfully waited on, from code outside of the condition, the condition status needs to be updated atomically. When the condition is waited for, and unblocked, resource counts need to be decremented from the contributing signaler.<\/p>\n Construction, destruction and operation of the condition needs to happen transparently, from direct operations on the member semaphores. We achieve this by each condition keeping a record of its member semaphores and their contribution to the resource count; and also, each member semaphore keeping a record of the list of conditions that it is entangled in. Construction and destruction of conditions needs to safely and correctly update entanglement lists.<\/p>\n A single critical section (Gate), is shared by all synchro objects and conditions that might be entangled together. The gate must be passed in as a construction parameter.<\/p>\n When the operating system call WaitForMultipleObjects() is available, it is used instead of the private condition semaphore. This call will be available if and only if:<\/p>\n Listing 1 below shows a solution for the aforementioned subset of the task. To implement other conditions, other than “unblock on first chronological member”, override the TSyncroCondition methods marked as virtual.<\/p>\n Abstract How can one write code to block (wait) on multiple syncro events at once, in a multi-threaded application? We are of course, talking about Delphi. By “multiple synchro events at once”, I mean that the thread unblocks on some … Continue reading Just Kill threads<\/h3>\n
Design Around<\/h3>\n
Design Above<\/h3>\n
Count-down Latch<\/h3>\n
\nThe code that signals the component semaphores has to know about the latch rules. That’s not a general solution.
\nWhat happens when something wants to wait directly on a component semaphore? The relationship between the component semaphores and the latch is destroyed. So you either have to have code to deal with this (complex), or the latch solution is just used in situations where the only consumer of either semaphore is the consumer of both. Another problem is that it may be inefficient (CPU-wise) for Windows.<\/p>\nOffered Solution<\/h1>\n
\n
The Full Source Code<\/h1>\n
\r\nunit SBD.TL.SyncObjs2;\r\ninterface\r\nuses System.SyncObjs, Generics.Collections, SysUtils;\r\n\r\nconst\r\n Forever = System.INFINITE;\r\n TimeOut = cardinal( $FFFFFFFF);\r\n WaitForError = 0;\r\n\r\ntype\r\n\r\n TSynchoConditionList = class;\r\n\r\n ISynchroCondition = interface;\r\n TSBDSemaphore = class\r\n private\r\n FEntangledConditions: TSynchoConditionList;\r\n FGate: TCriticalSection;\r\n FCount: cardinal;\r\n FMax: cardinal;\r\n FBase: TSemaphore;\r\n\r\n function BaseWaitFor( TimeLimit: cardinal): TWaitResult;\r\n procedure BaseSignal;\r\n procedure WaitedVia_External;\r\n\r\n public\r\n constructor Create( Gate: TCriticalSection; InitialCount, MaxCount: cardinal);\r\n destructor Destroy; override;\r\n function WaitFor( TimeLimit: cardinal): TWaitResult;\r\n function Signal: boolean;\r\n function Count: cardinal;\r\n function AsConditions( AConstrainToHandleSyncros: boolean): ISynchroCondition;\r\n end;\r\n\r\n ISynchroCondition = interface\r\n ['{CFD0DD74-6EB4-4CCF-9EE1-8BBAC759151A}']\r\n function WaitFor( TimeLimit: cardinal; var Contributor: TSBDSemaphore): TWaitResult;\r\n function Join( const Addend: ISynchroCondition): ISynchroCondition;\r\n end;\r\n\r\n IInterfaceHelper = interface\r\n ['{40D9B899-AF13-4FC1-AF04-23E8416E1FEE}']\r\n function AsObject: TObject;\r\n end;\r\n\r\n TSyncroCondition = class( TInterfacedObject, ISynchroCondition, IInterfaceHelper)\r\n protected\r\n \/\/ Override these methods to implement conditions other that "first chronological".\r\n function ConditionIsSignaled: boolean; virtual;\r\n function ConditionWillBeSignaledAfterSignal( Sem: TSBDSemaphore):boolean; virtual;\r\n function ConditionWillBeSignaledAfterWait ( Sem: TSBDSemaphore):boolean; virtual;\r\n function WaitCanUseOS_API: boolean; virtual;\r\n function OS_API_WaitFor( TimeLimit: cardinal; var Contributor: TSBDSemaphore): TWaitResult; virtual;\r\n\r\n private\r\n FisSignalled: boolean;\r\n FWillBeSignaled: boolean;\r\n FSignals: TDictionary<TSBDSemaphore,cardinal>;\r\n FGate: TCriticalSection;\r\n FisBroken: boolean;\r\n FBase: TSemaphore;\r\n FInited: boolean;\r\n FConstrainedToAllHandleSyncros: boolean;\r\n\r\n constructor CreateWithOne( Origin: TSBDSemaphore; AConstrainToHandleSyncros: boolean);\r\n destructor Destroy; override;\r\n\r\n procedure Presignal ( Sem: TSBDSemaphore);\r\n procedure Postsignal( Sem: TSBDSemaphore);\r\n procedure PostWait ( Sem: TSBDSemaphore);\r\n procedure BaseSignal;\r\n procedure BaseWaitForever;\r\n function BaseWaitFor( TimeLimit: cardinal): TWaitResult;\r\n function WaitFor( TimeLimit: cardinal; var Contributor: TSBDSemaphore): TWaitResult;\r\n function FindASignallingContributor( var Sem: TSBDSemaphore): boolean;\r\n procedure NotifyMemberDestroyed( Member: TSBDSemaphore);\r\n function AsObject: TObject;\r\n function Join( const Addend: ISynchroCondition): ISynchroCondition;\r\n procedure CheckInit;\r\n end;\r\n\r\n TSynchoConditionList = class( TList<TSyncroCondition>)\r\n public\r\n end;\r\n\r\nimplementation\r\n\r\n\r\n\r\n\r\nfunction TSBDSemaphore.Count: cardinal;\r\nbegin\r\nresult := FCount\r\nend;\r\n\r\nconstructor TSBDSemaphore.Create( Gate: TCriticalSection; InitialCount, MaxCount: cardinal);\r\nbegin\r\nAssert( MaxCount >= 1);\r\nAssert( InitialCount <= MaxCount);\r\nFGate := Gate;\r\nFBase := TSemaphore.Create( nil, InitialCount, MaxCount, '', False);\r\nFEntangledConditions := TSynchoConditionList.Create;\r\nFCount := InitialCount;\r\nFMax := MaxCount\r\nend;\r\n\r\ndestructor TSBDSemaphore.Destroy;\r\nvar\r\n Cnd: TSyncroCondition;\r\nbegin\r\nFGate.Enter;\r\ntry\r\n for Cnd in FEntangledConditions do\r\n Cnd.NotifyMemberDestroyed( self);\r\n FBase.Free\r\nfinally\r\n FGate.Leave\r\n end;\r\ninherited\r\nend;\r\n\r\nfunction TSBDSemaphore.Signal: boolean;\r\nvar\r\n Cnd: TSyncroCondition;\r\n Saturated: boolean;\r\nbegin\r\nFGate.Enter;\r\ntry\r\n Saturated := FCount >= FMax;\r\n if not Saturated then\r\n begin\r\n Inc( FCount);\r\n for Cnd in FEntangledConditions do\r\n Cnd.Presignal( self)\r\n end;\r\n BaseSignal;\r\n if not Saturated then\r\n for Cnd in FEntangledConditions do\r\n Cnd.Postsignal( self);\r\nfinally\r\n FGate.Leave\r\n end;\r\nend;\r\n\r\nprocedure TSyncroCondition.Presignal( Sem: TSBDSemaphore);\r\nbegin\r\nAssert( FGate = Sem.FGate);\r\nCheckInit;\r\nFWillBeSignaled := ConditionWillBeSignaledAfterSignal( Sem);\r\nFSignals[ Sem] := FSignals[ Sem] + 1;\r\nif (not FisSignalled) and FWillBeSignaled then\r\n BaseSignal;\r\nend;\r\n\r\nprocedure TSyncroCondition.BaseWaitForever;\r\nbegin\r\nBaseWaitFor( Forever)\r\nend;\r\n\r\nconstructor TSyncroCondition.CreateWithOne( Origin: TSBDSemaphore; AConstrainToHandleSyncros: boolean);\r\nbegin\r\nFisBroken := False;\r\nFGate := Origin.FGate;\r\nFConstrainedToAllHandleSyncros := AConstrainToHandleSyncros;\r\n{$IFDEF MSWINDOWS}\r\nif FConstrainedToAllHandleSyncros then\r\n Assert( Origin.FBase is THandleObject);\r\n{$ENDIF MSWINDOWS}\r\nFInited := False;\r\nFSignals := TDictionary<TSBDSemaphore,cardinal>.Create;\r\nFSignals.Add( Origin, Origin.FCount);\r\nFisSignalled := False;\r\nFWillBeSignaled := False;\r\nFBase := nil\r\nend;\r\n\r\nprocedure TSyncroCondition.CheckInit;\r\nvar\r\n InitialCount: cardinal;\r\nbegin\r\nif FInited then exit;\r\nFInited := True;\r\nFisSignalled := ConditionIsSignaled;\r\nFWillBeSignaled := FisSignalled;\r\nif FisSignalled then\r\n InitialCount := 0\r\n else\r\n InitialCount := 1;\r\nif not WaitCanUseOS_API then\r\n FBase := TSemaphore.Create( nil, InitialCount, 1, '', False)\r\nend;\r\n\r\n\r\ndestructor TSyncroCondition.Destroy;\r\nvar\r\n Member: TSBDSemaphore;\r\nbegin\r\nFGate.Enter;\r\ntry\r\n FisBroken := True;\r\n for Member in FSignals.Keys do\r\n Member.FEntangledConditions.Remove( self);\r\n FSignals.Free;\r\n FBase.Free\r\nfinally\r\n FGate.Leave\r\n end;\r\ninherited\r\nend;\r\n\r\nprocedure TSyncroCondition.NotifyMemberDestroyed( Member: TSBDSemaphore);\r\nbegin\r\nif FGate <> Member.FGate then\r\n FisBroken := True;\r\nif FisBroken then exit;\r\nFGate.Enter;\r\ntry\r\n if FSignals.ContainsKey( Member) then\r\n begin\r\n FisBroken := True;\r\n FSignals.Remove( Member)\r\n end\r\nfinally\r\n FGate.Leave\r\n end\r\nend;\r\n\r\nfunction TSyncroCondition.OS_API_WaitFor(\r\n TimeLimit: cardinal; var Contributor: TSBDSemaphore): TWaitResult;\r\n{$IFDEF MSWINDOWS}\r\nvar\r\n HandleObjs: THandleObjectArray;\r\n SignaledObj: THandleObject;\r\n Member: TSBDSemaphore;\r\n i: integer;\r\n{$ENDIF MSWINDOWS}\r\nbegin\r\n{$IFDEF MSWINDOWS}\r\n SetLength( HandleObjs, FSignals.Count);\r\n i := -1;\r\n for Member in FSignals.Keys do\r\n begin\r\n Inc( i);\r\n HandleObjs[ i] := Member.FBase as THandleObject\r\n end;\r\n result := THandleObject.WaitForMultiple( HandleObjs, TimeLimit, False, SignaledObj, False, 0);\r\n if result = wrSignaled then\r\n begin\r\n i := -1;\r\n for Member in FSignals.Keys do\r\n begin\r\n Inc( i);\r\n if SignaledObj <> Member.FBase then continue;\r\n Member.WaitedVia_External;\r\n break\r\n end\r\n end\r\n{$ELSE}\r\n result := wrError\r\n{$ENDIF MSWINDOWS}\r\nend;\r\n\r\nfunction TSyncroCondition.WaitCanUseOS_API: boolean;\r\nbegin\r\n{$IFDEF MSWINDOWS}\r\nresult := FConstrainedToAllHandleSyncros;\r\n{$ELSE}\r\nresult := False\r\n{$ENDIF MSWINDOWS}\r\nend;\r\n\r\nfunction TSyncroCondition.WaitFor(\r\n TimeLimit: cardinal; var Contributor: TSBDSemaphore): TWaitResult;\r\nvar\r\n TimeLeft: cardinal;\r\n AfterWaitClock, Elapsed: TDateTime;\r\n Confirmed: boolean;\r\n doRetry: boolean;\r\n Count: cardinal;\r\nbegin\r\nif FisBroken then\r\n begin\r\n result := wrAbandoned;\r\n exit\r\n end;\r\nCheckInit;\r\nif WaitCanUseOS_API then\r\n result := OS_API_WaitFor( TimeLimit, Contributor)\r\n else\r\n begin\r\n TimeLeft := TimeLimit;\r\n repeat\r\n result := BaseWaitFor( TimeLeft);\r\n if result <> wrSignaled then break;\r\n if TimeLeft > 0 then\r\n AfterWaitClock := Now;\r\n FGate.Enter;\r\n try\r\n Confirmed := FindASignallingContributor( Contributor);\r\n if Confirmed then\r\n begin\r\n result := Contributor.BaseWaitFor( 0);\r\n Confirmed := result = wrSignaled\r\n end;\r\n doRetry := result = wrTimeOut;\r\n if doRetry and (TimeLeft > 0) then\r\n begin\r\n Elapsed := Trunc( (Now - AfterWaitClock) * MSecsPerDay);\r\n if TimeLeft > Elapsed then\r\n Dec( TimeLeft, Elapsed)\r\n else\r\n TimeLeft := 0\r\n end;\r\n if Confirmed then\r\n begin\r\n Count := FSignals[ Contributor];\r\n if Count > 0 then\r\n FSignals[ Contributor] := Count - 1\r\n end;\r\n if ConditionIsSignaled then\r\n BaseSignal;\r\n finally\r\n FGate.Leave\r\n end;\r\n if doRetry then\r\n Sleep(1)\r\n until not doRetry\r\n end\r\nend;\r\n\r\nprocedure TSyncroCondition.Postsignal( Sem: TSBDSemaphore);\r\nbegin\r\nCheckInit;\r\nif FisSignalled and (not FWillBeSignaled) then\r\n BaseWaitForever\r\nend;\r\n\r\nprocedure TSBDSemaphore.WaitedVia_External;\r\nvar\r\n Cnd: TSyncroCondition;\r\n Saturated: boolean;\r\nbegin\r\nFGate.Enter;\r\ntry\r\n Saturated := FCount = 0;\r\n if not Saturated then\r\n begin\r\n Dec( FCount);\r\n for Cnd in FEntangledConditions do\r\n Cnd.PostWait( self)\r\n end\r\nfinally\r\n FGate.Leave\r\n end;\r\nend;\r\n\r\nfunction TSBDSemaphore.WaitFor( TimeLimit: cardinal): TWaitResult;\r\nbegin\r\nresult := BaseWaitFor( TimeLimit);\r\nif result = wrSignaled then\r\n WaitedVia_External\r\nend;\r\n\r\n\r\nprocedure TSyncroCondition.PostWait( Sem: TSBDSemaphore);\r\nvar\r\n WR: TWaitResult;\r\n Saturated: boolean;\r\n Count: cardinal;\r\nbegin\r\nAssert( FGate = Sem.FGate);\r\nAssert( not FisBroken);\r\nCheckInit;\r\nFWillBeSignaled := ConditionWillBeSignaledAfterWait( Sem);\r\nCount := FSignals[ Sem];\r\nif Count > 0 then\r\n FSignals[ Sem] := Count - 1;\r\nif FisSignalled <> FWillBeSignaled then\r\n begin\r\n if FWillBeSignaled then\r\n BaseSignal\r\n else\r\n BaseWaitForever\r\n end\r\nend;\r\n\r\n\r\nfunction TSBDSemaphore.AsConditions( AConstrainToHandleSyncros: boolean): ISynchroCondition;\r\nbegin\r\nresult := TSyncroCondition.Create( self, AConstrainToHandleSyncros);\r\nend;\r\n\r\nprocedure TSBDSemaphore.BaseSignal;\r\nbegin\r\nFBase.Release\r\nend;\r\n\r\nfunction TSBDSemaphore.BaseWaitFor( TimeLimit: cardinal): TWaitResult;\r\nbegin\r\nresult := FBase.WaitFor( TimeLimit)\r\nend;\r\n\r\n\r\nfunction TSyncroCondition.FindASignallingContributor(\r\n var Sem: TSBDSemaphore): boolean;\r\nvar\r\n Pair: TPair<TSBDSemaphore,cardinal>;\r\nbegin\r\nresult := not FisBroken;\r\nif not result then exit;\r\nresult := False;\r\nfor Pair in FSignals do\r\n begin\r\n result := Pair.Value > 0;\r\n if not result then continue;\r\n Sem := Pair.Key;\r\n break\r\n end\r\nend;\r\n\r\nfunction TSyncroCondition.AsObject: TObject;\r\nbegin\r\nresult := self\r\nend;\r\n\r\nfunction TSyncroCondition.Join(\r\n const Addend: ISynchroCondition): ISynchroCondition;\r\nvar\r\n Composite, Friend: TSyncroCondition;\r\n Pair: TPair<TSBDSemaphore,cardinal>;\r\n InitialCount: cardinal;\r\nbegin\r\nFGate.Enter;\r\ntry\r\n Composite := TSyncroCondition.Create;\r\n result := Composite;\r\n Friend := (Addend as IInterfaceHelper).AsObject as TSyncroCondition;\r\n Assert( FGate = Friend.FGate);\r\n Composite.FisBroken := FisBroken or Friend.FisBroken;\r\n Composite.FGate := FGate;\r\n FSignals := TDictionary<TSBDSemaphore,cardinal>.Create;\r\n for Pair in FSignals do\r\n Composite.FSignals.Add( Pair.Key, Pair.Value);\r\n for Pair in Friend.FSignals do\r\n begin\r\n if Composite.FSignals.ContainsKey( Pair.Key) then\r\n Composite.FSignals[ Pair.Key] := Composite.FSignals[ Pair.Key] + Friend.FSignals[ Pair.Key]\r\n else\r\n Composite.FSignals.Add( Pair.Key, Pair.Value)\r\n end;\r\n for Pair in Composite.FSignals do\r\n if Pair.Key.FEntangledConditions.IndexOf( self) = -1 then\r\n Pair.Key.FEntangledConditions.Add( self);\r\n Composite.FisSignalled := ConditionIsSignaled;\r\n Composite.FWillBeSignaled := FisSignalled;\r\n Composite.FInited := False;\r\n Composite.FBase := nil;\r\n {$IFDEF MSWINDOWS}\r\n Assert( FConstrainedToAllHandleSyncros = Friend.FConstrainedToAllHandleSyncros);\r\n {$ENDIF MSWINDOWS}\r\n Composite.FConstrainedToAllHandleSyncros := FConstrainedToAllHandleSyncros;\r\nfinally\r\n FGate.Leave\r\n end;\r\nend;\r\n\r\nprocedure TSyncroCondition.BaseSignal;\r\nbegin\r\nif assigned( FBase) then\r\n FBase.Release;\r\nFisSignalled := True\r\nend;\r\n\r\nfunction TSyncroCondition.BaseWaitFor( TimeLimit: cardinal): TWaitResult;\r\nbegin\r\nif assigned( FBase) then\r\n result := FBase.WaitFor( TimeLimit)\r\n else\r\n result := wrError;\r\nFisSignalled := False\r\nend;\r\n\r\n\r\nfunction TSyncroCondition.ConditionIsSignaled: boolean;\r\nvar\r\n Pair: TPair<TSBDSemaphore,cardinal>;\r\nbegin\r\nresult := False;\r\nfor Pair in FSignals do\r\n begin\r\n result := Pair.Value > 0;\r\n if not result then continue;\r\n break\r\n end\r\nend;\r\n\r\nfunction TSyncroCondition.ConditionWillBeSignaledAfterSignal(\r\n Sem: TSBDSemaphore): boolean;\r\nbegin\r\nresult := True\r\nend;\r\n\r\nfunction TSyncroCondition.ConditionWillBeSignaledAfterWait(\r\n Sem: TSBDSemaphore): boolean;\r\nvar\r\n Pair: TPair<TSBDSemaphore,cardinal>;\r\n Count, Sum: cardinal;\r\nbegin\r\nresult := False;\r\nSum := 0;\r\nfor Pair in FSignals do\r\n begin\r\n Count := Pair.Value;\r\n if (Pair.Key = Sem) and (Count > 0) then\r\n Dec( Count);\r\n Inc( Sum, Count);\r\n result := Sum > 0;\r\n if not result then continue;\r\n break\r\n end\r\nend;\r\n\r\n\r\nend.\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"