python 协程库gevent学习--gevent源码学习(二)

            import
             gevent



            def
             xixihaha(msg):
    
            print
            (msg)
    gevent.sleep(0)
    
            print
             msg

g1 = gevent.spawn(xixihaha, ‘xixi‘)
gevent.sleep(0)

    hub = get_hub()
    loop = hub.loop
    if seconds <= 0:
        waiter = Waiter()
        loop.run_callback(waiter.switch)
        waiter.get()
    else:
        hub.wait(loop.timer(seconds, ref=ref))

            def
             get(self):
        
            """
            If a value/an exception is stored, return/raise it. Otherwise until switch() or throw() is called.
            """
            if self._exception isnot _NONE:
            if self._exception is None:
                return self.value
            else:
                getcurrent().throw(*self._exception)
        else:
            if self.greenlet isnot None:
                raise ConcurrentObjectUseError(‘This Waiter is already used by %r‘ % (self.greenlet, ))
            self.greenlet = getcurrent()
            try:
                return self.hub.switch()
            finally:
                self.greenlet = None

            def
             switch(self):
        switch_out = getattr(getcurrent(), ‘switch_out‘, None)
        if switch_out isnot None:
            switch_out()
        return greenlet.switch(self)

            def
             run(self):
        
            """
            
        Entry-point to running the loop. This method is called automatically
        when the hub greenlet is scheduled; do not call it directly.

        :raises LoopExit: If the loop finishes running. This means
           that there are no other scheduled greenlets, and no active
           watchers or servers. In some situations, this indicates a
           programming error.
        
            """
            assert self is getcurrent(), ‘Do not call Hub.run() directly‘while True:
            loop = self.loop
            loop.error_handler = self
            try:
                loop.run()
            finally:
                loop.error_handler = None  # break the refcount cycle
            self.parent.throw(LoopExit(‘This operation would block forever‘, self))
        # this function must never return, as it will cause switch() in the parent greenlet# to return an unexpected value# It is still possible to kill this greenlet with throw. However, in that case# switching to it is no longer safe, as switch will return immediatelly

xixi

            def join(self, timeout=None):
        """Wait until the greenlet finishes or *timeout* expires.
        Return ``None`` regardless.
        """if self.ready():
            return

        switch = getcurrent().switch
        self.rawlink(switch)
        try:
            t = Timeout._start_new_or_dummy(timeout)
            try:
                result = self.parent.switch()
                if result isnot self:
                    raise InvalidSwitchError(‘Invalid switch into Greenlet.join(): %r‘ % (result, ))
            finally:
                t.cancel()
        except Timeout as ex:
            self.unlink(switch)
            if ex isnot t:
                raiseexcept:
            self.unlink(switch)
            raise

            def
             rawlink(self, callback):
        
            """
            Register a callable to be executed when the greenlet finishes execution.

        The *callback* will be called with this instance as an argument.

        .. caution:: The callable will be called in the HUB greenlet.
        
            """
            if
            not
             callable(callback):
            
            raise TypeError(‘Expected callable: %r‘ % (callback, ))
        self._links.append(callback)
        if self.ready() and self._links andnot self._notifier:
            self._notifier = self.parent.loop.run_callback(self._notify_links)

            def
             run(self):
        
            try
            :
            self.
            __cancel_start
            ()
            self._start_event = _start_completed_event

            try:
                result = self._run(*self.args, **self.kwargs)
            except:
                self._report_error(sys.exc_info())
                return
            self._report_result(result)
        finally:
            self.__dict__.pop(‘_run‘, None)
            self.__dict__.pop(‘args‘, None)
            self.__dict__.pop(‘kwargs‘, None)

            def
             _report_result(self, result):
        self._exc_info = (None, None, None)
        self.value = result
        if self._has_links() andnot self._notifier:
            self._notifier = self.parent.loop.run_callback(self._notify_links)

            def
             _notify_links(self):
        
            while
             self._links:
            link = self._links.popleft()
            try:
                link(self)
            except:
                self.parent.handle_error((link, self), *sys.exc_info())