C++博客-Thinking World-随笔分类-OShttp://www.cppblog.com/willcao/category/6883.html非澹泊无以明志,非宁静无以致远zh-cnWed, 17 Nov 2010 08:30:06 GMTWed, 17 Nov 2010 08:30:06 GMT60关于自旋锁和信号量的纠正http://www.cppblog.com/willcao/archive/2008/12/10/69103.htmlWillCaoWillCaoWed, 10 Dec 2008 12:49:00 GMThttp://www.cppblog.com/willcao/archive/2008/12/10/69103.htmlhttp://www.cppblog.com/willcao/comments/69103.htmlhttp://www.cppblog.com/willcao/archive/2008/12/10/69103.html#Feedback2http://www.cppblog.com/willcao/comments/commentRss/69103.htmlhttp://www.cppblog.com/willcao/services/trackbacks/69103.html  废话不多说了.首先从自旋锁的来源来看吧.说到这个就要说SMP,linux 在2.2的内核之后就加入了SMP的支持.一直到2.6越来越好.有SMP就有多个cpu的队列.每一个cpu都有一个自己的调度队列.这样在有些时候就需要平衡这些队列.这个时候就要用到锁,让其他cpu什么也不做.让一个cpu来更新这些队列.这个时候肯定是不能用信号量的(?).这样就出现了自旋锁.当然自旋锁的用途不止这里.比如说在中断中,进入临界区.信号量也是不能用的(?).这个时候就要用自旋锁,其他方面的话,我再回去看看.这样的话应该就很清楚了.信号量只是在进程中使用的.一般来说,应用级程序,你根本不用考虑自旋锁.没有SMP,也不用考虑了.因为代码编译以后只是禁止了内核抢占.这也就是说,这段代码不会被抢占,sleep什么的根本没用.如果是开发驱动方面的话,这个在必要的时候还是应该考虑一下.什么是必要的时候呢?就是上面我说的,进入中断临界区且有多个cpu.
 



WillCao 2008-12-10 20:49 发表评论
]]>关于子进程和父进程--fork函数http://www.cppblog.com/willcao/archive/2008/07/06/55490.htmlWillCaoWillCaoSun, 06 Jul 2008 15:40:00 GMThttp://www.cppblog.com/willcao/archive/2008/07/06/55490.htmlhttp://www.cppblog.com/willcao/comments/55490.htmlhttp://www.cppblog.com/willcao/archive/2008/07/06/55490.html#Feedback8http://www.cppblog.com/willcao/comments/commentRss/55490.htmlhttp://www.cppblog.com/willcao/services/trackbacks/55490.html    贴点代码稍稍解释一下:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int main(void)
{
        pid_t pid=fork();
        if(pid==0)
        {
                int j ;
                for(j=0;j<10;j++)
                {
                        printf("child: %d\n",j);
                        sleep(1);
                }
        }
        else if (pid>0)
        {
                int i;
                for(i=0;i<10;i++)
                {
                        printf("parent: %d\n",i);
                        sleep(1);
                }
        }
        else
        {
                fprintf(stderr,"can't fork ,error %d\n",errno);
                exit(1);
        }
        printf("This is the end !");
}
    运行了这段代码,我想应该所有人都应该了解fork了吧.运行的时候可以查看进程(ps -aux),会发现有两个一样的进程,运行结束后最后一句printf会运行两次,因为每个进程都会运行一次.中间的交替就是进程的调度了.我也是刚刚明白,还有很多东西要深刻理解.总算有点眉目了.很爽.



WillCao 2008-07-06 23:40 发表评论
]]>用代码来思考自旋锁和信号量http://www.cppblog.com/willcao/archive/2008/04/30/48527.htmlWillCaoWillCaoWed, 30 Apr 2008 08:45:00 GMThttp://www.cppblog.com/willcao/archive/2008/04/30/48527.htmlhttp://www.cppblog.com/willcao/comments/48527.htmlhttp://www.cppblog.com/willcao/archive/2008/04/30/48527.html#Feedback4http://www.cppblog.com/willcao/comments/commentRss/48527.htmlhttp://www.cppblog.com/willcao/services/trackbacks/48527.html自己学着别人小小的动了下手.
先贴信号量的代码.
#include<pthread.h>
#include<stdio.h>
#include<sys/time.h>

#define MAX 10
pthread_t thread[2];
pthread_mutex_t mut;
int number=0,i;

void * thread1()
{
    printf("thread1: I'm thread 1 \n");
    for(i =0;i<MAX ;i++)
    {
        printf("thread 1: number=%d \n",number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(2);
    }
    printf("thread1: 主函数在等我完成任务吗？\n");
    pthread_exit(NULL);
}
void *  thread2()
{
    printf("thread2: I'm thread 2 \n");
    for(i =0; i<MAX;i++)
    {
        printf("thread2 : number=%d\n",number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(3);
    }
    printf("thread2 : 主函数在等我完成任务么？\n");
    pthread_exit(NULL);

}

void thread_create(void)
{
    /*创建线程*/
    pthread_create(&thread[0],NULL,thread1,NULL);
    printf("线程1被创建！\n");
    pthread_create(&thread[1],NULL,thread2,NULL);
    printf("线程2被创建！\n");
}
void thread_wait(void)
{
    /*等待线程结束*/
    pthread_join(thread[0],NULL);
    printf("线程1已经结束！\n");
    pthread_join(thread[1],NULL);
    printf("线程2已经结束!\n");
}
int main()
{
    /*用默认属性初始化互斥锁*/
    pthread_mutex_init(&mut,NULL);
    printf("我是主函数，我正在创建线程！\n");
    thread_create();
    printf("我是主函数，我正在等待线程完成任务！\n");
    thread_wait();
}

执行的结果是:
我是主函数，我正在创建线程！
thread1: I'm thread 1
thread 1: number=0
线程1被创建！
thread2: I'm thread 2
thread2 : number=1
线程2被创建！
我是主函数，我正在等待线程完成任务！
thread 1: number=2
thread2 : number=3
thread 1: number=4
thread 1: number=5
thread2 : number=6
thread 1: number=7
thread2 : number=8
thread 1: number=9
thread2 : number=10
thread1: 主函数在等我完成任务吗？
线程1已经结束！
thread2 : 主函数在等我完成任务么？
线程2已经结束!

 重要:这个执行的过程大概要10秒!!!!!!
而我们用自旋锁,代码:
/*
 * time :2008.4.30
 * author:will cao
 * Email:sei_michael@126.com
 * 探索自旋锁与信号量的区别
 */
#include<pthread.h>
#include<stdio.h>

pthread_t thread[2];
pthread_spinlock_t lock ;

#define MAX 10

int number=0,i;

void * thread1()
{
    printf ("thread 1 :I began to run !");
    for(i=0;i<MAX;i++)
    {
        printf("thread 1 :number=%d \n",number);
        pthread_spin_lock(&lock);
        number++;
        pthread_spin_unlock(&lock);
    }
    printf("ok ,I am over !\n");
    pthread_exit(NULL);
}
void * thread2 ()
{
    printf("thread2 : I start !!!\n");
    for(i=0;i<MAX;i++)
    {
        printf("thread2 : number = %d \n",number);
        pthread_spin_lock(&lock);
        number++;
        pthread_spin_unlock(&lock);
    }
    printf("thread 2: I am over!!!");
    pthread_exit(NULL);
}

void thread_create(void)
{
    /*create the threads */
    pthread_create(&thread[0],NULL,thread1,NULL);
    printf("create the thread 1\n ");
    pthread_create(&thread[1],NULL,thread2,NULL);
    printf("create the thread 2 \n");
}
void thread_wait(void )
{
    /*wait for the thread to be over */
    pthread_join(thread[0],NULL);
    printf("the thread 1 is over !\n");
    pthread_join(thread[1],NULL);
    printf("the thread 2 is over ! \n");
}
int main()
{
    /* init the spin lock */
    pthread_spin_init(&lock,0);
    printf("i am the main,and I am creating the threads ");
    thread_create();
    printf("i am the main,and I am wait for the thread to be over!");
    thread_wait();
}
 执行结果为:
i am the main,and I am creating the threads thread 1 :I began to run !thread 1 :number=0
thread 1 :number=1
thread 1 :number=2
thread 1 :number=3
thread 1 :number=4
thread 1 :number=5
thread 1 :number=6
thread 1 :number=7
thread 1 :number=8
thread 1 :number=9
ok ,I am over !
create the thread 1
 thread2 : I start !!!
create the thread 2
i am the main,and I am wait for the thread to be over!thread2 : number = 10
thread2 : number = 11
thread2 : number = 12
thread2 : number = 13
thread2 : number = 14
thread2 : number = 15
thread2 : number = 16
thread2 : number = 17
thread2 : number = 18
thread2 : number = 19
thread 2: I am over!!!the thread 1 is over !
the thread 2 is over !
   执行时间:我没用系统调用,但肯定是用不了0.1秒的...
总结:从表面上来看,很明显的区别是当我们用的是信号量的时候,这个时候是有调度的.因为从运行结果上来看,主线程在创建其他两个线程后,其他线程开始运行.并且主线程也在运行.但怎么运行这个是无法确定的,这是一个并发的过程.
    当使用自旋锁后,这个就不一样了.当运行到临界区的时候,它是直接的过去,不是会产生一个等待,或者一个调度.
不知道编译器是怎么编译的.很想知道编译后二进制代码有什么区别.但这个好像有点太难....不过我觉得从运行结果上来看这么多,应该差不多了.




WillCao 2008-04-30 16:45 发表评论
]]>信号量与自旋锁http://www.cppblog.com/willcao/archive/2008/04/30/48496.htmlWillCaoWillCaoTue, 29 Apr 2008 17:32:00 GMThttp://www.cppblog.com/willcao/archive/2008/04/30/48496.html   首先说自旋锁.这个实现基本上是和TSL相同.TSL指令,首先是要共享一个lock,当进入临界区时,首先将lock复制到寄存器,然后将lock置为1,接下来看寄存器中的值是否为0,为0进入.不为0返回.而最重要的是它能保证指令执行的不可分割性,也就是说在这条指令结束之前,其他指令不允许访问内存.实现的是方式是在指令执行之前将内存总线禁止.结束后在打开内存总线.而自旋锁实现就是这个样子.只不过多循环了几次.为了更好的让cpu调度,在尝试一定次数后返回.因为他是一直在那边循环所以叫做自旋锁.可见这种锁很耗资源.但是速度上来说很快.一旦锁释放,立刻可以得到资源.
   再来看看信号量,信号量的实现就不这般精准了.如果使用一个信号量来控制一个临界区的话.就会有很多情况,首先最明显的是读者-写者问题.可以有多个读者,写者只可以有一个.并且信号量的实现也和自旋锁有者一定的区别.当一个信号量不能访问后.进程不会在那里循环,会被睡眠掉.当信号量可以使用的时候,调度器会从可以调度的进程选择一个.
   基本上就这个样子.

WillCao 2008-04-30 01:32 发表评论
]]>