精华内容
下载资源
问答
  • c++ multi thread message sending and notify 线程通信常用的方法有共享内存和消息传递,推荐使用消息传递。 最常用的就是管道了,可以使用匿名管道或者命名管道。...这里就涉及到线程间的唤醒操作...

    c++ multi thread message sending and notify

    线程通信常用的方法有共享内存和消息传递,推荐使用消息传递。

    最常用的就是管道了,可以使用匿名管道或者命名管道。
    匿名管道使用示例如下:

    
    

    命名管道就需要你在操作系统上创建一个真实的管道文件,具体做法就不展示了。

    说道管道有一个问题,那就是多个生产者和消费者的时候,如何通知消费者。

    这里就涉及到线程间的唤醒操作了,如果不唤醒线程,让消费者线程轮询进行不断地查询,效率太低了。

    线程唤醒比较好的操作是使用信号量 condition variable

    C++ 11开始std中提供了 std::lock_guard 和 std::unique_lock,这2种互斥锁。

    lock_guard的提供是为了帮你完成锁的加载与释放。

    比如说你在一个thread中进行mutex的lock操作,结果这个thread崩溃了,mutex永远不会unlock了,这种情况如果是自己写的话会发生,使用lock_guard就可以避免这种情况。

    当然,多线程无锁缓存的实现还有其他方法,如Linux内核2.6中实现了一个生产者和一个消费者的无锁访问环形缓冲区,可以查找相关资料进行学习,这里不再赘述。

    展开全文
  • linux内核线程唤醒函数wake_up_process()

    千次阅读 2018-12-24 20:09:06
    这个函数用于唤醒一个task。 其使用的例程如下: static void cmtp_reset_ctr(struct capi_ctr *ctrl) { struct cmtp_session *session = ctrl->driverdata; BT_DBG("ctrl %p", ctrl)...
    int wake_up_process(struct task_struct *p)
    这个函数用于唤醒一个task。
    其使用的例程如下:
    static void cmtp_reset_ctr(struct capi_ctr *ctrl)
    {
    	struct cmtp_session *session = ctrl->driverdata;
    
    	BT_DBG("ctrl %p", ctrl);
    
    	capi_ctr_down(ctrl);
    
    	atomic_inc(&session->terminate);
    	wake_up_process(session->task);
    }
    例如这个例子中就通过wake_up_process 来唤醒session->task
    其源码分析如下:
    int wake_up_process(struct task_struct *p)
    {
    	return try_to_wake_up(p, TASK_NORMAL, 0);
    }
    唤醒p到TASK_NORMAL 状态
    static int
    try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
    {
    	unsigned long flags;
    	int cpu, success = 0;
    
    	/*
    	 * If we are going to wake up a thread waiting for CONDITION we
    	 * need to ensure that CONDITION=1 done by the caller can not be
    	 * reordered with p->state check below. This pairs with mb() in
    	 * set_current_state() the waiting thread does.
    	 */
    	smp_mb__before_spinlock();
    	raw_spin_lock_irqsave(&p->pi_lock, flags);
    #如果task的状态已经等于要设的状态了,就退出吧,从这里知道,调用wake_up_process 不一定非得是sleep的task.正常task
    #也是可以的,只是不起作用而已,在这里就退出了.
    	if (!(p->state & state))
    		goto out;
    
    	trace_sched_waking(p);
    
    	/* We're going to change ->state: */
    	success = 1;
    #获得要wakeup 的task 原本是运行到哪个cpu上的
    	cpu = task_cpu(p);
    
    	/*
    	 * Ensure we load p->on_rq _after_ p->state, otherwise it would
    	 * be possible to, falsely, observe p->on_rq == 0 and get stuck
    	 * in smp_cond_load_acquire() below.
    	 *
    	 * sched_ttwu_pending()                 try_to_wake_up()
    	 *   [S] p->on_rq = 1;                  [L] P->state
    	 *       UNLOCK rq->lock  -----.
    	 *                              \
    	 *				 +---   RMB
    	 * schedule()                   /
    	 *       LOCK rq->lock    -----'
    	 *       UNLOCK rq->lock
    	 *
    	 * [task p]
    	 *   [S] p->state = UNINTERRUPTIBLE     [L] p->on_rq
    	 *
    	 * Pairs with the UNLOCK+LOCK on rq->lock from the
    	 * last wakeup of our task and the schedule that got our task
    	 * current.
    	 */
    	smp_rmb();
    #要唤醒的task 不在自己的rq上,也就是要唤醒其他rq上的task,所以这里会做remote wake up.
    	if (p->on_rq && ttwu_remote(p, wake_flags))
    		goto stat;
    
    #ifdef CONFIG_SMP
    	/*
    	 * Ensure we load p->on_cpu _after_ p->on_rq, otherwise it would be
    	 * possible to, falsely, observe p->on_cpu == 0.
    	 *
    	 * One must be running (->on_cpu == 1) in order to remove oneself
    	 * from the runqueue.
    	 *
    	 *  [S] ->on_cpu = 1;	[L] ->on_rq
    	 *      UNLOCK rq->lock
    	 *			RMB
    	 *      LOCK   rq->lock
    	 *  [S] ->on_rq = 0;    [L] ->on_cpu
    	 *
    	 * Pairs with the full barrier implied in the UNLOCK+LOCK on rq->lock
    	 * from the consecutive calls to schedule(); the first switching to our
    	 * task, the second putting it to sleep.
    	 */
    	smp_rmb();
    
    	/*
    	 * If the owning (remote) CPU is still in the middle of schedule() with
    	 * this task as prev, wait until its done referencing the task.
    	 *
    	 * Pairs with the smp_store_release() in finish_lock_switch().
    	 *
    	 * This ensures that tasks getting woken will be fully ordered against
    	 * their previous state and preserve Program Order.
    	 */
    	smp_cond_load_acquire(&p->on_cpu, !VAL);
    
    	p->sched_contributes_to_load = !!task_contributes_to_load(p);
    #先将task的状态设置为TASK_WAKING
    	p->state = TASK_WAKING;
    #task 如果是在等待io的时候sleep。则先结束这次io 操作?
    	if (p->in_iowait) {
    		delayacct_blkio_end();
    		atomic_dec(&task_rq(p)->nr_iowait);
    	}
    #根据wakup cpu选择要rq要运行到哪个cpu上
    	cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
    #如果wakeup后的cpu 和之前task 运行的cpu 不相等,则设置需要迁移的flag,方便以后进行迁移工作。并通过set_task_cpu将task 
    #wakeup 后的cpu保存在task中
    	if (task_cpu(p) != cpu) {
    		wake_flags |= WF_MIGRATED;
    		set_task_cpu(p, cpu);
    	}
    
    #else /* CONFIG_SMP */
    
    	if (p->in_iowait) {
    		delayacct_blkio_end();
    		atomic_dec(&task_rq(p)->nr_iowait);
    	}
    
    #endif /* CONFIG_SMP */
    #执行wakeup task 的操作
    	ttwu_queue(p, cpu, wake_flags);
    stat:
    #更新rq中相关统计数据
    	ttwu_stat(p, cpu, wake_flags);
    out:
    	raw_spin_unlock_irqrestore(&p->pi_lock, flags);
    
    	return success;
    }
    
    


    原文链接:https://blog.csdn.net/tiantao2012/article/details/78872831 
     

    展开全文
  • 本文实例讲述了基于C++实现的线程休眠代码,分享给大家供大家参考。具体方法如下:linux平台示例如下:/*File : thread1.cAuthor : MikeE-Mail : Mike_Zhang@live.com*/#include #include #include void m_thread...

    本文实例讲述了基于C++实现的线程休眠代码,分享给大家供大家参考。具体方法如下:

    linux平台示例如下:

    /*

    File : thread1.c

    Author : Mike

    E-Mail : Mike_Zhang@live.com

    */

    #include

    #include

    #include

    void m_threadSleep(int sec,int nsec)

    {

    struct timespec sleepTime;

    struct timespec returnTime;

    sleepTime.tv_sec = sec;

    sleepTime.tv_nsec = nsec;

    nanosleep(&sleepTime, &returnTime);

    }

    void test1()

    {

    m_threadSleep(1,0);

    printf("I'm thread1 ...\r\n");

    }

    void test2()

    {

    m_threadSleep(2,0);

    printf("I'm thread2 ...\r\n");

    }

    int main()

    {

    pthread_t thread1,thread2;

    void *result;

    time_t tbegin,tend;

    tbegin = time(NULL);

    pthread_create(&thread1,NULL,(void*)&test1,NULL);

    pthread_create(&thread2,NULL,(void*)&test2,NULL);

    pthread_join(thread1,&result);

    pthread_join(thread2,&result);

    tend = time(NULL);

    printf("%d\r\n",tend-tbegin);

    return 0;

    }

    编译代码如下:

    gcc thread1.c -o thread1 -lpthread

    boost库实现示例如下:

    /*

    File : boost_thread1.cpp

    Author : Mike

    E-Mail : Mike_Zhang@live.com

    */

    #include

    #include

    #include

    boost::xtime getSleepTime(int sec,int nsec)

    {

    boost::xtime t;

    boost::xtime_get(&t, boost::TIME_UTC);

    t.sec += sec;

    t.nsec += nsec;

    return t;

    }

    void test1()

    {

    boost::this_thread::sleep(getSleepTime(1,500));

    std::cout <

    }

    void test2()

    {

    boost::this_thread::sleep(getSleepTime(3,500));

    std::cout <

    }

    int main(int argc, char* argv[])

    {

    boost::thread thrd1(&test1);

    boost::thread thrd2(&test2);

    std::time_t t_begin,t_end;

    t_begin = time(NULL);

    thrd1.join();

    thrd2.join();

    t_end = time(NULL);

    std::cout<

    return 0;

    }

    编译命令如下:

    g++ boost_thread1.cpp -o boost_thread1 -lboost_thread-mt

    希望本文所述对大家的C++程序设计有所帮助。

    展开全文
  • linux线程的挂起和唤醒

    千次阅读 2017-09-05 15:49:22
    #include #include #include #include using namespace std; pthread_t IDA; pthread_t IDB;...pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;...pthread_cond_t cond = PTHREAD_COND_INITIALIZER;...
    #include <iostream>
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    
    using namespace std;
    
    pthread_t IDA;
    pthread_t IDB;
    
    pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    
    #define RUN 1
    #define STOP 0
    
    int status = RUN;
    
    void * thread_function(void *param)
    {
        static int i = 0;
        while (1)
        {
            pthread_mutex_lock(&mut);
            while (!status)
            {
                pthread_cond_wait(&cond, &mut);
            }
            pthread_mutex_unlock(&mut);
    
            //do actual something
            printf("thread is running...\n");
            sleep(1);
        }
    }
    
    void thread_resume()
    {
        if (status == STOP)
        {
            pthread_mutex_lock(&mut);
            status = RUN;
            pthread_cond_signal(&cond);
            printf("pthread run!\n");
            pthread_mutex_unlock(&mut);
        }
    }
    
    void thread_pause()
    {
        if (status == RUN)
        {
            pthread_mutex_lock(&mut);
            status = STOP;
            printf("thread stop!\n");
            pthread_mutex_unlock(&mut);
        }
    }
    
    void *test(void *param)
    {
        while(1)
        {
            sleep(5);
            thread_pause();
            sleep(10);
            thread_resume();
            sleep(5);
        }
    }
    
    
    int main(int argc, char *argv[])
    {
        pthread_create(&IDA, NULL, test, NULL);
        pthread_create(&IDB, NULL, thread_function, NULL);
    
        pthread_join(IDA, NULL);
        pthread_join(IDB, NULL);
    
        return 0;
    }

    展开全文
  • linux内核线程睡眠与唤醒

    万次阅读 2015-08-22 15:48:53
    :线程通过上面的步骤一直处在睡眠状态,当有别的线程将睡眠的线程唤醒之后,需要执行: set_current_state(TASK_RUNNING) 方式2 step1 :建立并初始化一个等待队列入口 DEFINE_WAIT(my_wait) step2 ...
  • 一、pthread_cond_wait()唤醒函数讲解 1.函数原型讲解 头文件 #include <pthread.h> 函数 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); 函数功能:实现线程的睡眠 参数1:条件...
  • LinuxLinux线程技术

    万次阅读 2018-09-05 15:57:23
    Linux线程概念 线程的概念 线程是计算机科学中的一个术语,是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流,也称为轻量进程。它是系统独立调度和分配的基本单位。同一进程中的多个线程...
  • Linux 线程挂起与唤醒功能 实例

    万次阅读 2014-04-11 09:35:09
    条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁...
  • Java线程等待唤醒机制(加深理解)

    万次阅读 多人点赞 2019-08-04 16:28:06
    今天看源码的时候遇到这样一个场景,某...下面代码是一个简单的线程唤醒机制示例,主要就是在Activity启动的时候初始化并start线程,线程start后会进入等待状态,在onResume方法中执行notify方法唤醒线程。通过这样...
  • 条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁...
  • linux线程线程同步(锁的应用)

    千次阅读 2018-06-08 15:36:33
    linux原本没有线程,后来在windows多线程编程影响下linux内核开发者在进程基础上在功能上做出了类似windows线程linux版本的线程linux线程归根到底还是进程,只不过是轻量级的进程,开销比真正进程要小得多,...
  • 这里贴出一个非常经典的关于多线程条件变量互斥锁的案例,即生产消费者模型。 我想说的是这里的while循环判断pthread_cond_wait,为何不能使用if的问题。 根据man查询到pthread_cond_signal这个函数至少会唤起1个...
  • ...在同步调用情况下,接口调用后调用者被阻塞,等待工作线程处理完成后,将调用者唤醒。伪代码如下:  [调用接口]  add_command(cmd, pi
  • Linux线程同步

    2015-11-20 08:47:27
    Linux中每一条线程在内存中对应了一个堆栈,我们没调用一个函数的时候,其实就是在内存中执行压入堆栈的操作。 而多线程就是在内存中有多个堆栈。每个堆栈的大小都是固定的,事先在内存中分配好的。当数据压入堆栈...
  • Java线程阻塞与唤醒

    2018-05-07 00:35:38
    Thread.suspend和Thread.resume因为容易导致死锁,很早以前就被标记为@deprecated,不建议使用了。我们把线程使用互斥锁访问的共享资源叫做...如果使用resume方法唤醒线程前需要获取监视器,那么死锁就会发生。当然...
  • 关于linux下信号量和条件变量的使用,在很多地方都可以找到相关文章,信号量、条件变量、互斥锁都是线程同步原语,在平时多线程编程中只要知道一两种就可以轻松搞定,我也是这么认为的,但是今天发现,有时还是有...
  • 线程的虚假唤醒

    千次阅读 2014-07-05 11:48:16
    (转载)线程唤醒的原因  2013-12-15 09:45:09| 分类: LINUX编程 | 标签:linuxunix知识 c++小知识 |举报|字号 订阅 线程唤醒的原因 ...From Wikipedia,
  • 今天在编程时,在一个线程中使用 pthread_cond_signal试图唤醒
  • Linux线程编程(不限Linux

    千次阅读 2011-11-11 16:57:18
    ——本文一个例子展开,介绍Linux下面线程的操作、多线程的同步和互斥。 前言 线程?为什么有了进程还需要线程呢,他们有什么区别?使用线程有什么优势呢?还有多线程编程的一些细节问题,如线程之间怎样同步、...
  • java线程虚假唤醒

    千次阅读 2016-04-05 14:03:33
    4. A线程调用notify(),唤醒等待中的线程A。 5. 如果此时, C获取到基于对象的锁,则优先执行,执行pop方法,获取数据,从list移除一个元素。 6. 然后,A获取到竞争锁,A中调用list.remove(list....
  • Linux线程的调度机制

    千次阅读 2019-01-10 21:32:49
    Linux线程的调度机制  在Linux中,线程是由进程来实现,线程就是轻量级进程( lightweight process ),因此在Linux中,线程的调度是按照进程的调度方式来进行调度的。Linux这样实现的线程的好处的之一是:线程调度...
  • 线程唤醒现象

    千次阅读 2010-07-30 01:37:00
    加入条件变量上有多个线程在等待,pthread_cond_broadcast会唤醒所有的等待线程,而pthread_cond_signal只会唤醒其中一个等待线程。这样,pthread_cond_broadcast的情况也许要在pthread_cond_wait前使用while循环来...
  • Linux线程介绍

    千次阅读 2013-04-20 13:04:54
    1、进程与线程2、使用线程的理由3、有关线程操作的函数4、线程之间的互斥5、线程之间的同步6、试题最终代码 1、进程与线程 进程是程序执行时的一个实例,即它是程序已经执行到何种程度的数据结构的汇集。从...
  • linux内核线程

    万次阅读 2018-10-16 18:22:49
    内核经常需要在后台执行一些操作,这种任务就可以通过内核线程(kernle thread)完成,内核线程是独立运行在内核空间的标准进程。...实际上,内核线程只能由其他内核线程创建,linux驱动模块中可以用kernel_threa...
  • Linux线程编程

    千次阅读 2011-08-26 10:24:55
    线程(thread)技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期, solaris是这方面的佼佼者。传统的Unix也支持线程的概念,但是在一个进程(process)中只允许有一个线程,这样多线程就...
  • Linux线程

    千次阅读 2009-01-08 16:14:00
    一:Linux线程编程: 线程(thread)技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期,solaris是这方面的佼佼者。传统的Unix也支持线程的概念,但是在一个进程(process)中只允许有一...
  • Linux内核线程

    千次阅读 2013-08-14 15:15:56
    内核线程是直接由内核本身启动的进程。内核线程实际上是将内核函数委托给独立的进程,与系统中其他进程“并行”执行(实际上,也并行于内核自身的执行),内核线程经常被称为内核“守护进程”。它们主要用于执行下列...
  • Linux - 线程通信

    千次阅读 2015-05-16 09:28:23
    线程互斥机制Mutex变量就像一把“锁”,是线程同步和保护共享数据的主要方式 Mutex可以用来阻止竞争 Pthreads中Mutex的基本概念 在任何时候,只有一个线程能够获得Mutex 尽管几个线程想获取一个Mutex,但是只有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,972
精华内容 20,788
关键字:

线程唤醒linux

linux 订阅