精华内容
下载资源
问答
  • c++11 并发编程 --- 条件变量(condition_variable) waitwait_for
    千次阅读
    2021-10-21 06:12:59

    介绍condition_variable, wait,wait_for
    直接上代码如下:

    #include <iostream>                // std::cout
    #include <thread>                // std::thread
    #include <mutex>                // std::mutex, std::unique_lock
    #include <condition_variable>    // std::condition_variable
    
    std::mutex mtx; // 全局互斥锁.
    std::condition_variable cv; // 全局条件变量.
    bool ready = false; // 全局标志位.
    
    
    void do_print_id(int id)
    {
        std::unique_lock <std::mutex> lck(mtx); // 加锁互斥量
        while (!ready) 
        {
            cv.wait(lck); // 当ready==false的时候,while语句执行到wait这里,然后就堵塞到这行,等到通知信号,同时解锁互斥量,不影响其他线程获取锁。 
        }                 //当 cv.notify_all(); // 唤醒所有线程. 执行到这句wait就收到了信号就被唤醒开始干活,首先就是不断的尝试重新获取并加锁互斥量。
                          //若获取不到锁就卡在这里反复尝试加锁
                          //若获取到了锁才往下执行
      
        std::cout << "thread " << id << '\n';
    }
    
    void go()
    {
        std::unique_lock <std::mutex> lck(mtx);
        ready = true; // 设置全局标志位为 true.
        cv.notify_all(); // 唤醒所有线程.
    }
    
    int main()
    {
        std::thread threads[10];
        // spawn 10 threads:
        for (int i = 0; i < 10; ++i)
            threads[i] = std::thread(do_print_id, i);
    
        std::cout << "10 threads ready to race...\n";
        go(); // go!
    
      for (auto & th:threads)
            th.join();
    
        return 0;
    }

    wait_for

    与std::condition_variable::wait() 类似,不过 wait_for可以指定一个时间段,在当前线程收到通知或者指定的时间 rel_time 超时之前,该线程都会处于阻塞状态。
    而一旦超时或者收到了其他线程的通知,wait_for返回,剩下的处理步骤和 wait()类似。

    #include <iostream>           // std::cout
    #include <thread>             // std::thread
    #include <chrono>             // std::chrono::seconds
    #include <mutex>              // std::mutex, std::unique_lock
    #include <condition_variable> // std::condition_variable, std::cv_status
    std::condition_variable cv;
    int value;
    void do_read_value()
    {
        std::cin >> value;
        cv.notify_one(); //只有键盘敲入一个字符,才往下执行cv.notify_one();
    }
    
    int main ()
    {
        std::cout << "Please, enter an integer (I'll be printing dots): \n";
        std::thread th(do_read_value);
        std::mutex mtx;
        std::unique_lock<std::mutex> lck(mtx); //加锁互斥量
        while (cv.wait_for(lck,std::chrono::seconds(1)) == std::cv_status::timeout) { //这里wait_for堵塞到这一行,解锁互斥量。
                   std::cout << '.';                                                  //当超时1s的时候,相当于收到了通知信号,就被唤醒干活了。 加锁互斥量
                   std::cout.flush();                                                 //while语句满足就执行打印.
        }                                                                             //然后再次循环再wait等待1s,循环反复。
                                                                                      //但是当收到cv.notify_one();的时候,不满足 std::cv_status::timeout,就会退出循环。
        std::cout << "You entered: " << value << '\n';                                //这个时候不断尝试加锁互斥量,加锁成功往下执行。加锁不成功不断尝试加锁。
        th.join();
        return 0;
    }

    这里的现像就是终端不断的在打印.

    Please, enter an integer (I'll be printing dots): 
    .................................

    当我敲一个字符的时候,就会停止打印

    Please, enter an integer (I'll be printing dots): 
    ...............................................................................q.
    You entered: 0
    按 <RETURN> 来关闭窗口...

    在多线程任务中,往往需要多个线程往同一个队列添加或者取数据,就需要用到条件变量,当你push了一个数据到队列,你就可以通知另外取数据的线程可以去取数据了。
    当你取走一个数据的时候,你就可以通知压(push)数据的线程可以往线程压数据了,队列刚刚空出一个位置了就可以压数据了。
    代码如下:

    #include <mutex>      
    #include <deque>
    #include <condition_variable>
    
    
    template <class T>
    class my_buffer
    {
    public:
    	my_buffer(const char* name, int max_size = 30)
    		:_terminal(false)
    		, _max_size(max_size)
    		, _name(name)
    		, _last_warning_time(0)
    	{
    
    	}
    
    	~my_buffer(void)
    	{
    	}
    
    	bool push(const T& value)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		while (_job_list.size() >= _max_size && !_terminal)
    		{
    			_push_cond.wait(lck);
    		}
    
    		if (_terminal)
    		{
    			return false;
    		}
    
    		_job_list.push_back(value);
    		_pop_cond.notify_one();//push了一个数据就可以通知取数据pop的线程有数据可以取了。
    		return true;
    	}
    
    	bool async_push(const T& value, float& capacity_rate)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		/*while (_job_list.size() >= _max_size && !_terminal)
    		{
    			_push_cond.wait(lck);
    		}*/
    
    		if (_job_list.size() >= _max_size)
    		{
    			capacity_rate = _job_list.size() / ((float)_max_size);
    			return false;
    		}
    
    		/*if (_terminal)
    		{
    			return false;
    		}*/
    
    		_job_list.push_back(value);
    		_pop_cond.notify_one();//push了一个数据就可以通知取数据pop的线程有数据可以取了。
    
    		capacity_rate = _job_list.size() / ((float)_max_size);
    		return true;
    	}
    
    	bool push_front(const T& value)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		while (_job_list.size() >= _max_size && !_terminal)
    		{
    			_push_cond.wait(lck);
    		}
    
    		if (_terminal)
    		{
    			return false;
    		}
    
    		_job_list.push_front(value);
    		_pop_cond.notify_one();//push了一个数据就可以通知取数据pop的线程有数据可以取了。
    		return true;
    	}
    
    	bool pop(T& value)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		while (_job_list.empty() && !_terminal)
    		{
    			_pop_cond.wait(lck);
    		}
    			
    		if (_terminal)
    		{
    			return false;
    		}
    
    		value = *_job_list.begin();
    		_job_list.pop_front();
    		_push_cond.notify_one();//取走一个数据就可以通知压数据的条件变量了
    
    		return true;
    	}
    
    	bool pop_wait(T& value, int second)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		if (_job_list.empty())
    		{
                if (std::cv_status::timeout == _pop_cond.wait_for(lck, std::chrono::milliseconds(second)))
    			{
    				return false;
    			}		
    		}
    
    		value = *_job_list.begin();
    		_job_list.pop_front();
    		_push_cond.notify_one();//取走一个数据就可以通知压数据的条件变量了
    
    		return true;
    	}
    	
    	void clear(void)
    	{
    		_terminal = true;
    		_push_cond.notify_all();
    		_pop_cond.notify_all();
    	}
    
    	void flush(void)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		_job_list.clear();
    	}
    
    	void reset(void)
    	{
    		_terminal = false;
    	}
    
    	size_t size(void)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		return _job_list.size();
    	}
    
    	float capacity_rate(void)
    	{
    		std::unique_lock <std::mutex> lck(_mutex);
    		return _job_list .size()/ ((float)_max_size);
    	}
    private:
    	std::deque<T> _job_list; //队列				
    	std::mutex _mutex;  //互斥量						
    	std::condition_variable _pop_cond;		
    	std::condition_variable _push_cond;	
    	volatile bool _terminal;				
    	unsigned long _max_size;//容器最大空间
    	std::string _name;
    	time_t _last_warning_time;
    };
    更多相关内容
  • wait_for_completion_timeout函数功能描述:此函数用于阻塞当前进程,等待其他进程的执行结束,被等待进程保存在输入参数的wait字段所代表的等待队列中。有两种情况可以结束此种等待:第一,当等待队列中的进程被...

     

    概述

    wait_for_completion_timeout函数功能描述:此函数用于阻塞当前进程,等待其他进程的执行结束,被等待进程保存在输入参数的wait字段所代表的等待队列中。有两种情况可以结束此种等待:第一,当等待队列中的进程被函数complete( )或函数complete_all( )唤醒,等待结束,阻塞进程将继续执行;第二,当等待的时钟节拍超时时,被阻塞的进程会继续执行。

    此函数将当前进程设置为不可中断的等待状态,所以即使通过Ctrl+C组合键也不能强制结束等待;此函数设置的等待时间是函数的第二个参数所代表的系统时钟节拍数,这个时间是可以更改的。

    文章目录

    wait_for_completion_timeout文件包含

    #include <linux/completion.h>
    

    C

    wait_for_completion_timeout函数定义

    在内核源码中的位置:linux-3.19.3/kernel/sched/completion.c

    函数定义格式:

    unsigned long __sched wait_for_completion_timeout(struct completion*x, unsigned long timeout)
    

    wait_for_completion_timeout输入参数说明

    此函数的第一个输入参数是struct completion结构体类型的指针,包含一个等待队列信息及等待队列的状态信息,等待队列的状态代表此等待队列是否被唤醒过,其定义及详细解释参考函数complete( )分析文档的输入参数说明部分。

    此函数的第二个输入参数是unsigned long型的变量,代表等待的时钟节拍数,当等待的时钟节拍数超过此值时,被阻塞的进程将继续执行。

    wait_for_completion_timeout返回参数说明

    此函数的返回结果是unsigned long型的变量,代表剩余的系统时钟节拍数,即传入的第二个参数所代表的时钟节拍数与等待进程结束消耗的时钟节拍之差。如果等待是正常结束,则返回值的范围在0到函数的第二个输入参数值之间。

    wait_for_completion_timeout实例解析

    编写测试文件:wait_for_completion_timeout.c

    头文件引用及全局变量定义:

    /*头文件引用*/
    #include <linux/module.h>
    #include <linux/sched.h>
    #include <linux/pid.h>
    #include <linux/wait.h>
    #include <linux/completion.h>
    #include <linux/kthread.h>
    MODULE_LICENSE("GPL");
    
    /*全局变量定义*/
    static struct completion comple;         //用于保存completion的状态
    static struct task_struct * old_thread; //保存初始化进程信息
    

    子进程处理函数定义:

    int my_function(void * argc)
    {
        wait_queue_head_t head;
        wait_queue_t data;
        printk("in the kernel thread function! \n");
        init_waitqueue_head(&head);                     //初始化等待队列头元素
        init_waitqueue_entry(&data, current);           //用当前进程初始化等待队列元素
        add_wait_queue(&head, &data);                   //将当前进程插入到等待队列中
        schedule_timeout_uninterruptible(10);           //将等待队列置于不可中断的等待状态
        printk("the current pid is:%d\n", current->pid);     //显示当前进程的PID值
        printk("the state of the real_parent is :%ld\n", old_thread->state);
                                                        //显示父进程的状态
        //complete(&comple);                            //调用函数唤醒进程,并更改done字段的值
        printk("out the kernel thread function\n");
        return 0;
    }
    

    模块加载函数定义:

    static int __init wait_for_completion_timeout_init(void)
    {
        struct task_struct * result;
        long leavetime;
        wait_queue_t data;
        printk("into wait_for_completion_timeout_init.\n");
        old_thread = current;
    
        result=kthread_create_on_node(my_function, NULL, -1, "wait_for_completion_timeout");
                                              // 创建新进程
    
        wake_up_process(result);
        init_completion(&comple);             //初始化completion变量
        init_waitqueue_entry(&data, result); //用新进程初始化等待队列元素
        __add_wait_queue_tail(&(comple.wait), &data);         //将新进程加入等待队列的尾部
        leavetime=wait_for_completion_timeout(&comple,100); //阻塞进程,等待新进程的结束
        /*显示函数wait_for_completion_timeout( )的返回结果*/
        printk("the result of the wait_for_completion_timeout is:%ld\n", leavetime);
        /*显示函数kernel_thread( )函数的返回结果*/
        printk("the pid of new thread is :%d\n", result->pid);
        printk("the current pid is:%d\n", current->pid);      //显示当前进程的PID值
        printk("out wait_for_completion_timeout_init.\n");
        return 0;
    }
    

    模块退出函数定义:

    static void __exit wait_for_completion_timeout_exit(void)
    {
        printk("Goodbye wait_for_completion_timeout\n");
    }
    

    模块加载、退出函数调用:

    module_init(wait_for_completion_timeout_init);
    module_exit(wait_for_completion_timeout_exit);
    

    实例运行结果及分析:

    首先编译模块,执行命令insmod wait_for_completion_timeout.ko插入内核模块,此时终端会出现短暂的停顿,因为进程阻塞所至,当终端恢复命令行模式时,输入命令dmesg -c会出现如图A所示的结果。

    Linux内核API wait_for_completion_timeout

    去掉子进程处理函数中对语句“complete(&comple); ”的注释,保存文件,重新编译、加载模块,此时不会出现终端短暂的停顿的现象,输入命令dmesg -c,会出现如图B所示的结果。

    Linux内核API wait_for_completion_timeout

    结果分析:

    从图A和图B可以看出在子进程执行时父进程的状态值都是2,即父进程处于不可中断的等待状态,并且子进程都在父进程之前执行完毕,父进程会等待子进程的执行完毕。

    A中显示函数wait_for_completion_timeout( )的返回结果是0,可以推测此等待是正常结束的,实际情况是因等待超时而程序正常运行结束的。

    B中显示函数wait_for_completion_timeout( )的返回结果是90,可以推测等待是正常结束的,实际情况是通过调用函数complete( )唤醒等待队列中的进程,使等待提前结束,返回结果90是等待剩余的时钟节拍数,所消耗的时钟节拍数是10。

    说明
    对于子进程处理函数中调用函数schedule_timeout_uninterruptible( )使子进程进入短暂的睡眠,是为了保证父进程中的函数wait_for_completion( )能够在子进程中显示父进程状态之前被执行,从而能看到函数wait_for_completion( )对当前进程的作用。

    进程状态说明:

    对于进程能够处于的状态,在函数__wake_up( )的进程状态说明部分有详细的说明。

    展开全文
  • 文章目录结构体init_completioncompletewait_for_completion 结构体 struct completion { unsigned int done; wait_queue_head_t wait; }; #define UINT_MAX (~0U) init_completion #define init_completion(x) ...

    快速链接:
    .
    👉👉👉 个人博客笔记导读目录(全部) 👈👈👈

    • 在wait_for_completion时,先将x->wait加入到等待队列,在检查done的值,如果为0 ,则死循环卡住。推出循环后,则done–;
    • 在complete时,先done++,在wake_up(x->wait)等待队列
      注意done–的最小值和done++的最大值都是(~0U)

    结构体

    struct completion {
    	unsigned int done;
    	wait_queue_head_t wait;
    };
    
    #define UINT_MAX	(~0U)
    

    init_completion

    #define init_completion(x) __init_completion(x)
    
    static inline void __init_completion(struct completion *x)
    {
    	x->done = 0;
    	init_waitqueue_head(&x->wait);
    }
    

    complete

    void complete(struct completion *x)
    {
    	unsigned long flags;
    
    	spin_lock_irqsave(&x->wait.lock, flags);
    
    	if (x->done != UINT_MAX)
    		x->done++;
    	__wake_up_locked(&x->wait, TASK_NORMAL, 1);
    	spin_unlock_irqrestore(&x->wait.lock, flags);
    }
    EXPORT_SYMBOL(complete);
    

    wait_for_completion

    wait_for_completion --> wait_for_common --> do_wait_for_common

    void __sched wait_for_completion(struct completion *x)
    {
    	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
    }
    EXPORT_SYMBOL(wait_for_completion);
    
    
    static long __sched wait_for_common(struct completion *x, long timeout, int state)
    {
    	return __wait_for_common(x, schedule_timeout, timeout, state);
    }
    
    static inline long __sched __wait_for_common(struct completion *x,
    		  long (*action)(long), long timeout, int state)
    {
    	might_sleep();
    
    	complete_acquire(x);
    
    	spin_lock_irq(&x->wait.lock);
    	timeout = do_wait_for_common(x, action, timeout, state);
    	spin_unlock_irq(&x->wait.lock);
    
    	complete_release(x);
    
    	return timeout;
    }
    
    static inline long __sched do_wait_for_common(struct completion *x,
    		   long (*action)(long), long timeout, int state)
    {
    	if (!x->done) {
    		DECLARE_WAITQUEUE(wait, current);
    
    		__add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
    		do {
    			if (signal_pending_state(state, current)) {
    				timeout = -ERESTARTSYS;
    				break;
    			}
    			__set_current_state(state);
    			spin_unlock_irq(&x->wait.lock);
    			timeout = action(timeout);
    			spin_lock_irq(&x->wait.lock);
    		} while (!x->done && timeout);
    		__remove_wait_queue(&x->wait, &wait);
    		if (!x->done)
    			return timeout;
    	}
    	if (x->done != UINT_MAX)
    		x->done--;
    	return timeout ?: 1;
    }
    

    wait_for_completion的相关API

    wait_for_completion
    wait_for_completion_timeout
    wait_for_completion_interruptible
    wait_for_completion_killable
    wait_for_completion_killable_timeout
    wait_for_completion_io
    wait_for_common_io

    TASK_UNINTERRUPTIBLE
    TASK_INTERRUPTIBLE
    TASK_KILLABLE

    默认等待时间为MAX_SCHEDULE_TIMEOUT=LONG_MAX,也就是等于一个最大的数字((long)(~0UL >> 1)) = 9223372036854775807
    void __sched wait_for_completion(struct completion *x)
    {
    	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
    }
    
    
    unsigned long __sched wait_for_completion_timeout(struct completion *x, unsigned long timeout)
    {
    	return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
    }
    
    int __sched wait_for_completion_interruptible(struct completion *x)
    {
    	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
    	if (t == -ERESTARTSYS)
    		return t;
    	return 0;
    }
    
    long __sched wait_for_completion_interruptible_timeout(struct completion *x,
    					  unsigned long timeout)
    {
    	return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
    }
    
    int __sched wait_for_completion_killable(struct completion *x)
    {
    	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
    	if (t == -ERESTARTSYS)
    		return t;
    	return 0;
    }
    
    long __sched wait_for_completion_killable_timeout(struct completion *x,
    				     unsigned long timeout)
    {
    	return wait_for_common(x, timeout, TASK_KILLABLE);
    }
    
    void __sched wait_for_completion_io(struct completion *x)
    {
    	wait_for_common_io(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
    }
    
    unsigned long __sched wait_for_completion_io_timeout(struct completion *x, unsigned long timeout)
    {
    	return wait_for_common_io(x, timeout, TASK_UNINTERRUPTIBLE);
    }
    

    wait_for_common和wait_for_common_io的区别,区别在于schedule_timeout和io_schedule_timeout变量,这两个变量是指向函数的指针

    static long __sched wait_for_common(struct completion *x, long timeout, int state)
    {
    	return __wait_for_common(x, schedule_timeout, timeout, state);
    }
    
    static long __sched wait_for_common_io(struct completion *x, long timeout, int state)
    {
    	return __wait_for_common(x, io_schedule_timeout, timeout, state);
    }
    

    下方的action(timeout),其实就是在调用schedule_timeout(xxx)或io_schedule_timeout(xxx)

    static inline long __sched do_wait_for_common(struct completion *x,
    		   long (*action)(long), long timeout, int state)
    {
    	if (!x->done) {
    		DECLARE_WAITQUEUE(wait, current);
    
    		__add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
    		do {
    			if (signal_pending_state(state, current)) {
    				timeout = -ERESTARTSYS;
    				break;
    			}
    			__set_current_state(state);
    			spin_unlock_irq(&x->wait.lock);
    			timeout = action(timeout);
    			spin_lock_irq(&x->wait.lock);
    		} while (!x->done && timeout);
    		__remove_wait_queue(&x->wait, &wait);
    		if (!x->done)
    			return timeout;
    	}
    	if (x->done != UINT_MAX)
    		x->done--;
    	return timeout ?: 1;
    }
    
    展开全文
  • 备库wait_for_log

    千次阅读 2022-02-21 17:59:37
    logfile文件大小不一致

    问题

    在这里插入图片描述

    分析

    主库查看
    在这里插入图片描述
    主库切归档
    在这里插入图片描述
    备库可以看到归档

    在这里插入图片描述
    查看备库standby redo

    select group#,thread#,sequence#,archived,status,bytes/1024/1024 MB from v$standby_log;
    

    在这里插入图片描述
    查看主库redo

    select thread#, group#, status, bytes/1024/1024 MB from v$log order by 1, 2;
    

    在这里插入图片描述
    猜测主库redo比备库standby redo小导致

    解决方案:

    alter database recover managed standby database cancel;
    alter database add standby logfile thread 1 size 2G;
    
    # alter database clear logfile group x;
    # alter system archive log current;
    
    alter database drop standby logfile group x;
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    Bingo

    在这里插入图片描述

    展开全文
  • ADG备库wait_for_log

    千次阅读 2021-11-28 11:11:22
    Media Recovery Waiting for thread 1 sequence 406 Sun Nov 28 12:00:08 2021 RFS[1]: Opened log for thread 1 sequence 406 dbid 333435123 branch 1087663221 Archived Log entry 348 added for thread 1 ...
  • C++ wait_for

    千次阅读 2021-01-14 18:09:08
    在看xsens的ROS驱动源码时,遇到了如下代码,其中涉及到了多线程里的wait_for函数: // Returns empty packet on timeout RosXsDataPacket XdaCallback::next(const std::chrono::milliseconds &timeout) { ...
  • wait_for_completion_timeout(&tx_done_complete,msecs_to_jiffies(100)); complete(&tx_done_complete); 分析围绕这三个函数进行 init_completion struct completion { unsigned int done; wait_...
  • – MRP0一直显示WAIT_FOR_GAP 现象: MRP0一直显示WAIT_FOR_GAP的状态。 有了上次的教训,这次看到MRP0一直是WAIT_FOR_GAP的状态,先看看StandbyREDO是否正确构建了,答案是完全没问题。 接下来确认各种信息: ...
  • ADG RFS和MRP
  • Wait for frames will block until frame is available. Poll for frames will always return instantly... There is also try_wait_for_frames that will block but not throw on timeout but rather return false....
  •   现在我们来讨论下write.wait_for_active_shards、index.refresh_interval和refresh参数的作用: write.wait_for_active_shards   这个参数是指,索引请求返回前需要等待多少个分片写入成功,默认是1,只要主...
  • ADG备库MRP0状态WAIT_FOR_GAP

    千次阅读 2021-07-30 15:51:39
    重启备库等待应用即可。
  • wait_for模块

    千次阅读 2020-07-04 13:39:07
    wait_for模块就是干这个的。等待一个事情发生,然后继续。它可以等待某个端口被占用,然后再做下面的事情,也可以在一定时间超时后做另外的事。 常用参数 参数名 是否必须 默认值 选项 说明 connect_timeout...
  • C++11 wait_for函数理解

    千次阅读 2020-12-07 13:44:05
    //最后一个参数是预制条件,调用wait_for的时候,首先就会判断这个条件, //如果这个条件返回false,那么会继续等待,如果再超时之前,收到了一个notify //那么他会再次执行这个预制条件来进行判断,超时的时候也还...
  • 当 std::condition_variable 对象的某个 wait 函数被调用的时候,它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞,直到另外一个线程在相同的 std::condition_variable 对象上调用...
  • Ansible(14)wait_for模块

    千次阅读 2018-08-14 23:30:31
    wait_for 只是用来在规定时间内检测,状态是否为所期望的状态是才,才执行后续的操作 如: - name: Checking free port for transfer  wait_for:  host: {{ inventory_hostname }}  port: 6088  state: ...
  • ansible_api_wait_for_condition
  • 进程调度API之wait_for_completion_x

    千次阅读 2017-12-18 08:30:39
    wait_for_completion_x 是一系列函数用于等待完成量释放task,这里以常见的wait_for_completion为例 void __sched wait_for_completion(struct completion *x) { wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_...
  • grpc 的server.wait_for_termination如果报错,可以按照如下代码代替,python版本的: import time def serve(): log = QscLog() server = grpc.server(futures.ThreadPoolExecutor(max_workers=20)) add_...
  • wait_for提供了两个更多功能:>允许定义超时,>让你指定循环你的例子:await f1await asyncio.wait_for(f1, None) # or simply asyncio.wait_for(f1)两个等待都将无限期地等待结果(或异常).在这种情况下,平原...
  • 如图,一号四号摄像头视频流显示卡住了,但流传输并未停止,使用目标检测发现,摄像头每次传过来的都是同样的一帧; 但也有可能是加了这句,导致空帧被跳过了: ...如果是这样,那么到底是什么问题导致wait_fo...
  • 我猜想Intel Realsense D435摄像头只要启动pipeline.start()函数,就会开始传输帧,无论我们是否调用wait_for_frames()或者poll_for_frames()函数,它都会传输,但是我没有办法去验证我的这个猜想,去咨询官方客服...
  • 配置好realsense的环境后,安装好pyrealsense2,就能利用python开启关闭摄像头并对视频流进行相关的计算处理 ... 之前能正常使用,某一天报此错误: ...frames = pipeline.wait_for_frames() RuntimeEr...
  • 在导入的过程中遇到了一个问题:导入物料基本信息与分类信息是分作两次请求进行提交的,导入分类信息的请求必须是物料基本信息请求提交成功后才提交的,于是就用到了FND_CONCURRENT.WAIT_FOR_REQUEST来等待物料基本...
  • completion和wait_for_event的区别

    千次阅读 2016-11-09 22:54:59
    A进程调用wait_for_completion(&data->prev_finished);  等待其他进程对data->prev_finished执行complete操作。 B进程调用complete(&next->prev_finished);  通知等待在next->prev_finished上的进程可
  • Linux 内核Complete和wait_for_completion

    千次阅读 2014-11-11 14:45:18
    总之,wait_for_completion的作用是使当前进程处于TASK_UNINTERRUPTIBLE,处于等待队列,不再运行。进一步说,就是该函数只能在有进程上下文的情况下调用。 3. complete(struct completion *) void ...
  • 今天小鱼来说说ROS2的客户端中wait_for_service()函数函数使用方法,帮助大家理解。 一、函数介绍 1.1 函数功能: 等待服务端准备完成。 1.2 函数输入输出: #mermaid-svg-TjMNRK8ScjaeV0mQ .label{font-family:'...
  • 有些情况需要调用其他的并发程序去处理相应的事务,此时父并发请求进入等待状态,当子程序完成之后接着去处理其他的业务,为了实现这种情况需要使用到FUNCTION FND_CONCURRENT.WAIT_FOR_REQUEST 这个功能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 628,928
精华内容 251,571
关键字:

wait_for