C++博客-Jiwu Bu

Linux内核VFS---rootfs文件系统加载

bujiwu — Sun, 04 Jul 2010 08:58:00 GMT

对linux-2.6.34源码rootfs文件系统加载学习笔记

1.内核启动调用start_kernel函数进行初始化。

asmlinkage void __init start_kernel(void) //init\Main.c:528
{
    buffer_init();
    key_init();
    security_init();
    vfs_caches_init(totalram_pages);//678行，vfs初始化
    signals_init();
}

2.start_kernel调用vfs_caches_init对vfs进行初始化。

//fs\Dcach.c:2354行
void __init vfs_caches_init(unsigned long mempages)
{
    .......
    dcache_init();
    inode_init();
    files_init(mempages);
    mnt_init(); //mnt初始化
    bdev_cache_init();
    chrdev_init();
}

3.在vfs_caches_init调用fs\namespace.c 2321行的mnt_init函数

void __init mnt_init(void)
{

    init_rootfs();    //初始化rootfs文件系统
    init_mount_tree(); //初始化加载树
}

4. fs\ramfs第308行的init_rootfs函数初始化rootfs文件系统

int __init init_rootfs(void)
{
    int err;

    err = bdi_init(&ramfs_backing_dev_info);
    if (err)
        return err;

    err = register_filesystem(&rootfs_fs_type);//注册rootfs文件系统
    if (err)
        bdi_destroy(&ramfs_backing_dev_info);

    return err;
}

rootfs文件系统信息fs\ramfs第289行

static struct file_system_type rootfs_fs_type = {
    .name        = "rootfs",
    .get_sb        = rootfs_get_sb,
    .kill_sb    = kill_litter_super,
};

5.调用register_filesystem函数将rootfs注册到file_systems文件系统中。

//fs\Filesystem.c第69行。
int register_filesystem(struct file_system_type * fs)
{
    int res = 0;
    struct file_system_type ** p;

    BUG_ON(strchr(fs->name, '.'));
    if (fs->next)
        return -EBUSY;
    INIT_LIST_HEAD(&fs->fs_supers);
    write_lock(&file_systems_lock);
    p = find_filesystem(fs->name, strlen(fs->name));//查找到文件系统加载位置
    if (*p)
        res = -EBUSY;
    else
        *p = fs;
    write_unlock(&file_systems_lock);
    return res;
}

file_systems变量是所有文件系统链表的头指针。通过以上过程rootfs_fs_type就加入到了file_systems链表头的file_system_type类型的链表中。可以通过file_systems指针遍历这个链表，得到特定的文件系统file_system_type 指针。

bujiwu 2010-07-04 16:58 发表评论

[转载]top命令详解

bujiwu — Tue, 27 Apr 2010 05:26:00 GMT

http://blog.chinaunix.net/u/12973/showart_637900.html

top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器。下面详细介绍它的使用方法。

top - 01:06:48 up 1:22, 1 user, load average: 0.06, 0.60, 0.48
Tasks: 29 total,   1 running, 28 sleeping,   0 stopped,   0 zombie
Cpu(s): 0.3% us, 1.0% sy, 0.0% ni, 98.7% id, 0.0% wa, 0.0% hi, 0.0% si
Mem:    191272k total,   173656k used,    17616k free,    22052k buffers
Swap:   192772k total,        0k used,   192772k free,   123988k cached

   PID USER      PR NI VIRT RES SHR S %CPU %MEM    TIME+ COMMAND
1379 root      16   0 7976 2456 1980 S 0.7 1.3   0:11.03 sshd
14704 root      16   0 2128 980 796 R 0.7 0.5   0:02.72 top
     1 root      16   0 1992 632 544 S 0.0 0.3   0:00.90 init
     2 root      34 19     0    0    0 S 0.0 0.0   0:00.00 ksoftirqd/0
     3 root      RT   0     0    0    0 S 0.0 0.0   0:00.00 watchdog/0

统计信息区

前五行是系统整体的统计信息。第一行是任务队列信息，同 uptime 命令的执行结果。其内容如下：

01:06:48	当前时间
up 1:22	系统运行时间，格式为时:分
1 user	当前登录用户数
load average: 0.06, 0.60, 0.48	系统负载，即任务队列的平均长度。三个数值分别为 1分钟、5分钟、15分钟前到现在的平均值。

第二、三行为进程和CPU的信息。当有多个CPU时，这些内容可能会超过两行。内容如下：

Tasks: 29 total	进程总数
1 running	正在运行的进程数
28 sleeping	睡眠的进程数
0 stopped	停止的进程数
0 zombie	僵尸进程数
Cpu(s): 0.3% us	用户空间占用CPU百分比
1.0% sy	内核空间占用CPU百分比
0.0% ni	用户进程空间内改变过优先级的进程占用CPU百分比
98.7% id	空闲CPU百分比
0.0% wa	等待输入输出的CPU时间百分比
0.0% hi
0.0% si

最后两行为内存信息。内容如下：

Mem: 191272k total	物理内存总量
173656k used	使用的物理内存总量
17616k free	空闲内存总量
22052k buffers	用作内核缓存的内存量
Swap: 192772k total	交换区总量
0k used	使用的交换区总量
192772k free	空闲交换区总量
123988k cached	缓冲的交换区总量。内存中的内容被换出到交换区，而后又被换入到内存，但使用过的交换区尚未被覆盖，该数值即为这些内容已存在于内存中的交换区的大小。相应的内存再次被换出时可不必再对交换区写入。

进程信息区

统计信息区域的下方显示了各个进程的详细信息。首先来认识一下各列的含义。

序号	列名	含义
a	PID	进程id
b	PPID	父进程id
c	RUSER	Real user name
d	UID	进程所有者的用户id
e	USER	进程所有者的用户名
f	GROUP	进程所有者的组名
g	TTY	启动进程的终端名。不是从终端启动的进程则显示为 ?
h	PR	优先级
i	NI	nice值。负值表示高优先级，正值表示低优先级
j	P	最后使用的CPU，仅在多CPU环境下有意义
k	%CPU	上次更新到现在的CPU时间占用百分比
l	TIME	进程使用的CPU时间总计，单位秒
m	TIME+	进程使用的CPU时间总计，单位1/100秒
n	%MEM	进程使用的物理内存百分比
o	VIRT	进程使用的虚拟内存总量，单位kb。VIRT=SWAP+RES
p	SWAP	进程使用的虚拟内存中，被换出的大小，单位kb。
q	RES	进程使用的、未被换出的物理内存大小，单位kb。RES=CODE+DATA
r	CODE	可执行代码占用的物理内存大小，单位kb
s	DATA	可执行代码以外的部分(数据段+栈)占用的物理内存大小，单位kb
t	SHR	共享内存大小，单位kb
u	nFLT	页面错误次数
v	nDRT	最后一次写入到现在，被修改过的页面数。
w	S	进程状态。 D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
x	COMMAND	命令名/命令行
y	WCHAN	若该进程在睡眠，则显示睡眠中的系统函数名
z	Flags	任务标志，参考 sched.h

默认情况下仅显示比较重要的 PID、USER、PR、NI、VIRT、RES、SHR、S、%CPU、%MEM、TIME+、COMMAND 列。可以通过下面的快捷键来更改显示内容。

更改显示内容

通过 f 键可以选择显示的内容。按 f 键之后会显示列的列表，按 a-z 即可显示或隐藏对应的列，最后按回车键确定。

按 o 键可以改变列的显示顺序。按小写的 a-z 可以将相应的列向右移动，而大写的 A-Z 可以将相应的列向左移动。最后按回车键确定。

按大写的 F 或 O 键，然后按 a-z 可以将进程按照相应的列进行排序。而大写的 R 键可以将当前的排序倒转。

命令使用

1．工具（命令）名称
top
2．工具（命令）作用
显示系统当前的进程和其他状况； top是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止. 比较准确的说,top命令提供了实时的对系统处理器的状态监视.它将显示系统中CPU最“敏感”的任务列表.该命令可以按CPU使用.内存使用和执行时间对任务进行排序；而且该命令的很多特性都可以通过交互式命令或者在个人定制文件中进行设定.
3．环境设置
在Linux下使用。
4．使用方法
4．1使用格式
top [-] [d] [p] [q] [c] [C] [S] [s] [n]
4．2参数说明
d 指定每两次屏幕信息刷新之间的时间间隔。当然用户可以使用s交互命令来改变之。
p 通过指定监控进程ID来仅仅监控某个进程的状态。
q该选项将使top没有任何延迟的进行刷新。如果调用程序有超级用户权限，那么top将以尽可能高的优先级运行。
S 指定累计模式
s 使top命令在安全模式中运行。这将去除交互命令所带来的潜在危险。
i 使top不显示任何闲置或者僵死进程。
c 显示整个命令行而不只是显示命令名
4.3其他
下面介绍在top命令执行过程中可以使用的一些交互命令。从使用角度来看，熟练的掌握这些命令比掌握选项还重要一些。这些命令都是单字母的，如果在命令行选项中使用了s选项，则可能其中一些命令会被屏蔽掉。
Ctrl+L 擦除并且重写屏幕。
h或者? 显示帮助画面，给出一些简短的命令总结说明。
k 终止一个进程。系统将提示用户输入需要终止的进程PID，以及需要发送给该进程什么样的信号。一般的终止进程可以使用15信号；如果不能正常结束那就使用信号9强制结束该进程。默认值是信号15。在安全模式中此命令被屏蔽。
i 忽略闲置和僵死进程。这是一个开关式命令。
q 退出程序。
r 重新安排一个进程的优先级别。系统提示用户输入需要改变的进程PID以及需要设置的进程优先级值。输入一个正值将使优先级降低，反之则可以使该进程拥有更高的优先权。默认值是10。
S 切换到累计模式。
s 改变两次刷新之间的延迟时间。系统将提示用户输入新的时间，单位为s。如果有小数，就换算成m s。输入0值则系统将不断刷新，默认值是5 s。需要注意的是如果设置太小的时间，很可能会引起不断刷新，从而根本来不及看清显示的情况，而且系统负载也会大大增加。
f或者F 从当前显示中添加或者删除项目。
o或者O 改变显示项目的顺序。
l 切换显示平均负载和启动时间信息。
m 切换显示内存信息。
t 切换显示进程和CPU状态信息。
c 切换显示命令名称和完整命令行。
　M 根据驻留内存大小进行排序。
P 根据CPU使用百分比大小进行排序。
T 根据时间/累计时间进行排序。
W 将当前设置写入~/.toprc文件中。这是写top配置文件的推荐方法。

bujiwu 2010-04-27 13:26 发表评论

[转载]C函数atoi的实现

bujiwu — Fri, 15 Jan 2010 09:52:00 GMT

转载链接:http://blog.chinaunix.net/u2/76292/showart_1845022.html

1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <ctype.h>
4
5 long my_atol(const char *nptr)
6 {
7     int c; /* current char */
8     long total; /* current total */
9     int sign; /* if '-', then negative, otherwise positive */
10
11     /* skip whitespace */
12     while ( isspace((int)(unsigned char)*nptr) )
13     {
14         ++nptr;
15     }
16
17     c = (int)(unsigned char)*nptr++;
18     sign = c; /* save sign indication */
19     if (c == '-' || c == '+')
20     {
21         c = (int)(unsigned char)*nptr++; /* skip sign */
22     }
23
24     total = 0;
25
26     while (isdigit(c))
27     {
28         total = 10 * total + (c - '0'); /* accumulate digit */
29         c = (int)(unsigned char)*nptr++; /* get next char */
30     }
31
32     if (sign == '-')
33     {
34        return -total;
35     }
36     else
37     {
38         return total; /* return result, negated if necessary */
39     }
40 }
41
42 int  main(int argc, char* argv[])
43 {
44     if( argc < 2 )
45     {
46         return -1;
47     }
48
49     int i = my_atol(argv[1]);
50     printf("[%s]====>[%d]\n", argv[1], i);
51
52     int j = atoi(argv[1]);
53     printf("[%s]====>[%d]\n", argv[1], j);
54
55     return 0;
56 }
57

http://www.cppblog.com/Files/bujiwu/atoi.rar

bujiwu 2010-01-15 17:52 发表评论

Unix Network Programming - Vol2 读书笔记(Chapter 9. Record Locking)

bujiwu — Fri, 18 Dec 2009 07:57:00 GMT

使用Record Locking只启动一个进程实例。通过记录锁锁文件方式实现。

#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define FILE_PATH   "LockFile.txt"
#define MAXLINE     4096    /* max text line length */
#define FILE_MODE   (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

int LockSet(int fd, int Type)
{
    struct flock lock;

    lock.l_type = Type;        /* F_RDLCK, F_WRLCK, F_UNLCK */
    lock.l_start = 0;          /* byte offset, relative to l_whence */
    lock.l_whence = SEEK_END;  /* SEEK_SET, SEEK_CUR, SEEK_END */
    lock.l_len = 0;            /* #bytes (0 means to EOF) */

    return fcntl( fd, F_SETLK, &lock);
}

int main(int argc, char **argv)
{
    char line[MAXLINE] = {0};

    int fd = open(FILE_PATH, O_RDWR | O_CREAT| O_APPEND , FILE_MODE);

    if ( LockSet(fd, F_WRLCK) < 0 )
    {
        if (errno == EACCES || errno == EAGAIN)
        {
            printf("This program has running!\n");
            close(fd);
        }
        else
        {
            printf("call fcntl function error.%s\n", strerror(errno) );
        }

        exit(1);
    }

    printf("lock file [%s] successful\n", FILE_PATH);

    snprintf(line, sizeof(line), "%ld\n", (long) getpid());

    lseek(fd, 0, SEEK_END);
    write(fd, line, strlen(line));

    getchar();

    if ( LockSet(fd, F_UNLCK) < 0 )
    {
        printf("call fcntl function error.%s\n", strerror(errno) );
    }

    close(fd);

    return 0;
}

http://www.cppblog.com/Files/bujiwu/RecordLocking.rar

bujiwu 2009-12-18 15:57 发表评论

boost::filestream组件封装

bujiwu — Mon, 23 Nov 2009 05:44:00 GMT

为了方便日常使用boost::filestream组件，将boost::filestream组件的基本封装。

/**
* @file FileSystem.h
* @brief Operation file or diretory
* @author Jiwu Bu
* @version 1.0.0
* @date 2009-11-23
*/
#ifndef FILESYSTEM_H_H
#define FILESYSTEM_H_H

#include <iostream>
#include <vector>

using namespace std;

class CFileSystem
{
public:
    /**
     * @brief Gets an array of dirctories from current direcoty,
     *        using Recur value to determine whether to search
     *        subdirectories.
     * @param SubDirVec Ouput parameter, return the search result
     * @param DirPath
     * @param Recur  Whether search subdirectories.
     *
     * @return
     */
    static bool GetDirectories(vector<string>& SubDirVec,
        const string& DirPath, bool Recur = false);

    /**
     * @brief Get the names of files in the specified directory that
     *        match the specified extensive name, using a value to
     *        determine whether to search subdirectories.
     *
     * @param FileVec Ouput parameter, return the search result
     * @param DirPath
     * @param ExeName Extensive name, if ExeName equal  "*.*"  search all file
     * @param Recur   Whether search subdirectories
     *
     * @return
     */
    static bool GetFiles(vector<string>& FileVec, const string& DirPath,
        const string& ExeName, bool Recur = false);

    /**
     * @brief Create a new directory.
     *
     * @param Dir  New directory path. Example:/home/bujiwu/test
     *
     * @return  true, if success
     *          false, if failed
     */
    static bool CreateDirectory(const string & Dir);

    /**
     * @brief Judge whether this file or diretory exists.
     *
     * @param Path
     *
     * @return  true, if exists
     *          false, if not exists
     */
    static bool Exists(const string& Path);

    /**
     * @brief Delete this file or directory
     *
     * @param Path
     */
    static void Delete(const string& Path);

    /**
     * @brief Move file or directory from FromPath to ToPath.
     *
     * @param FromPath
     * @param ToPath
     */
    static void Move(const string& FromPath, const string& ToPath);

    /**
     * @brief Copy file or directory from FromPath to ToPath.
     *
     * @param FromPath
     * @param ToPath
     */
    static void Copy(const string& FromPath, const string& ToPath);

    /**
     * @brief Get file size
     *
     * @param FilePath
     *
     * @return
     */
    static unsigned long GetFileSize(const string& FilePath);
};

#endif

测试用例：

#include "../FileSystem/FileSystem.h"
#include <algorithm>
#include <iterator>
#include <string>

using namespace std;

int main(int argc, char* argv[])
{
    vector<string> MyVec;

    string Path = "/home/bujiwu/EncapDirectory";

    CFileSystem::Copy("/home/bujiwu/epoll", Path);

    CFileSystem::GetFiles(MyVec, Path, "*.*", true);

    copy(MyVec.begin(), MyVec.end(), ostream_iterator<string>(cout , "\n") );

    return 0;
}

http://www.cppblog.com/Files/bujiwu/FileSystem.rar

bujiwu 2009-11-23 13:44 发表评论

在Linux与Winodws下编译boost

bujiwu — Mon, 23 Nov 2009 05:31:00 GMT

需要编译的库：
date_time
filesystem
function_types
graph
iostreams
math
mpi
program_options
python
regex
serialization
signals
system
test
thread
wave

Windows:
1、开始菜单--Microsoft Visual Studio 2008--Visual Studio Tools---Open Visual Studio 2008 Command Prompt 打开命令行窗口
3、利用cd命令进入到：boost->toos->jam->src目录
4、编译，vc 2008输入命令：build vc9
5、把生成的bjam.exe(bin.ntx86目录下)拷贝到Boost根目录下，输入命令：
6、bjam --with-regex

Linux:
$cd path/to/boost_1_40_0
$ ./bootstrap.sh
产生bjam文件

$ ./bjam install 安装所有
$./bjam --with-regex 安装特定的库
$./bjam --with-filesystem

#./bjam --with-filesystem "-sTOOLS=gcc" "--includedir=/usr/include" "--libdir=/usr/lib/boost" install

bujiwu 2009-11-23 13:31 发表评论

semaphore信号学习笔记

bujiwu — Tue, 17 Nov 2009 05:28:00 GMT

使用信号量sem_t实现生产者与消费者实例。主要用到以下几个函数:
sem_init()
sem_destroy()
sem_post()
sem_wait()

//g++ -o semaphore semaphore.cpp  -lpthread
#include <semaphore.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "ThreadMutex.h"

#define MAXSIZE 10

sem_t g_sem_max;
sem_t g_sem_zero;

CThreadMutex g_mutex;

int g_count = 0;

int sem_wait_i(sem_t* psem)
{
    int rv = 0;

    while ( 0 != ( rv = sem_wait(psem) ) )
    {
        if ( errno == EINTR )
        {
            continue;
        }
        else
        {
            printf("sem_wait %s\n", strerror(errno) );
            break;
        }
    }

    return rv;
}

void* producer_thread(void* Parameter)
{
    while( true )
    {
        sleep(2);

        if( sem_wait_i(&g_sem_max) != 0 )
        {
            break;
        }

        g_mutex.Lock();

        g_count++;

        printf("Producer=%d\n", g_count);

        sem_post(&g_sem_zero);

        g_mutex.UnLock();
    }

    return NULL;
}

void* consumer_thread(void* Parameter)
{
    while( true )
    {
        sleep(3);

        if( sem_wait_i(&g_sem_zero) != 0 )
        {
            break;
        }

        g_mutex.Lock();

        g_count--;

        printf("Consumer=%d\n", g_count);

        sem_post(&g_sem_max);

        g_mutex.UnLock();
    }

    return NULL;
}

int main(int argc, char* argv[])
{
    if ( sem_init(&g_sem_zero, 0, 0) != 0 )
    {
        printf("sem_init %s\n", strerror(errno) );

        return -1;
    }

    if ( sem_init(&g_sem_max, 0, MAXSIZE) != 0 )
    {
        printf("sem_init %s\n", strerror(errno) );

        return -1;
    }

    pthread_t pro_thread;
    pthread_t sum_thread;

    if ( pthread_create( &sum_thread, NULL, consumer_thread, NULL) != 0 )
    {
        printf("pthread_create%s\n", strerror(errno) );

        return -1;
    }

    if ( pthread_create( &pro_thread, NULL, producer_thread, NULL) != 0 )
    {
        printf("pthread_create%s\n", strerror(errno) );

        return -1;
    }

    if ( pthread_join(pro_thread, NULL) != 0 )
    {
        printf("pthread_join %s\n", strerror(errno) );

        return -1;
    }

    if ( pthread_join(sum_thread, NULL) != 0 )
    {
        printf("pthread_join %s\n", strerror(errno) );

        return -1;
    }

    sem_destroy(&g_sem_zero);
    sem_destroy(&g_sem_max);

    return 0;
}

http://www.cppblog.com/Files/bujiwu/semaphore.rar

bujiwu 2009-11-17 13:28 发表评论

setitimer函数使用笔记

bujiwu — Mon, 16 Nov 2009 05:50:00 GMT

函数原型 int setitimer(int which, const struct itimerval *value,
                     struct itimerval *ovalue);

DESCRIPTION
       The system provides each process with three interval timers, each decrementing in a distinct time domain. When any timer expires, a
       signal is sent to the process, and the timer (potentially) restarts.

       ITIMER_REAL    decrements in real time, and delivers SIGALRM upon expiration.

       ITIMER_VIRTUAL decrements only when the process is executing, and delivers SIGVTALRM upon expiration.

       ITIMER_PROF    decrements both when the process executes and when the system is executing on behalf of the process.   Coupled with
                      ITIMER_VIRTUAL, this timer is usually used to profile the time spent by the application in user and kernel space. SIG-
                      PROF is delivered upon expiration.

       Timer values are defined by the following structures:

            struct itimerval {
                struct timeval it_interval; /* next value */
                struct timeval it_value;    /* current value */
            };
            struct timeval {
                long tv_sec;                /* seconds */
                long tv_usec;               /* microseconds */
            };

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/time.h>
#include <errno.h>

void PrintMsg(int Num)
{
    printf("%s\n", "Hello World");

    return;
}

int main(int argc, char* argv[])
{
    signal(SIGALRM, PrintMsg);

    struct itimerval tick;
    tick.it_value.tv_sec = 10;  //十秒钟后将启动定时器
    tick.it_value.tv_usec = 0;
    tick.it_interval.tv_sec  =1; //定时器启动后，每隔1秒将执行相应的函数
    tick.it_interval.tv_usec = 0;

    //setitimer将触发SIGALRM信号
    int ret = setitimer(ITIMER_REAL, &tick, NULL);

    if ( ret != 0)
    {
        printf("Set timer error. %s \n", strerror(errno) );

        return -1;
    }

    printf("Wait!\n");

    getchar();

    return 0;
}

bujiwu 2009-11-16 13:50 发表评论

pthread_mutex_t封装

bujiwu — Sun, 08 Nov 2009 12:57:00 GMT

常常需要使用pthread_mutex线程同步，每次都要使用pthread_mutex_init, pthread_mutex_lock, pthread_unlock, pthread_mutex_destroy这几个函数，干脆封装一下，以便以后重用。

//Mutex.cpp
#include <pthread.h>
#include <iostream>
using namespace std;

class ThreadMutex
{
public:
    ThreadMutex()
    {
        pthread_mutex_init(&mtx, NULL);
    }

    ~ThreadMutex()
    {
        pthread_mutex_destroy( &mtx );
    }

    inline void Lock()
    {
        pthread_mutex_lock( &mtx );
    }

    inline void UnLock()
    {
        pthread_mutex_unlock( &mtx );
    }

private:
    pthread_mutex_t mtx;
};

//以下为测试用例
ThreadMutex g_Mutex;

void *PrintMsg(void *lpPara)
{
    char *msg = (char *)lpPara;

    g_Mutex.Lock();

    for(int i=0; i< 5; i++ )
    {
        cout << msg << endl;
        sleep( 1 );
    }

    g_Mutex.UnLock();

    return NULL;
}

int main()
{
    pthread_t t1,t2;

    //创建两个工作线程，第1个线程打印10个1，第2个线程打印10个2。
    pthread_create( &t1, NULL, &PrintMsg, (void *)"First print thread" );
    pthread_create( &t2, NULL, &PrintMsg, (void *)"Second print thread" );

    //等待线程结束
    pthread_join( t1, NULL);
    pthread_join( t2, NULL);

    return 0;
}

通过g++ -o Mutex Mutex.cpp -lpthread编译。

bujiwu 2009-11-08 20:57 发表评论

进程间通讯--System V 共享内存

bujiwu — Sun, 08 Nov 2009 01:39:00 GMT

进程一将数据写入共享内存，进程二从共享内存读取数据

#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>

using namespace std;

int main(int argc, char* argv[])
{
    key_t key = ftok("/etc/passwd", 'a');
    if( -1 == key )
    {
        fprintf(stderr, "Creat Key Error:%s\n", strerror(errno));
        return -1;
    }

    /*
     if your IPC are used by processes related bya fork()
    (parent-children-grandchildren) use IPC_PRIVATE as the key
    */
    int shm_id=shmget( key, 1024, IPC_CREAT |0660);

    if( shm_id == -1 )
    {
        if ( shmctl(shm_id, IPC_RMID, NULL) == -1 )
        {
            fprintf(stderr, "shmctl remove shmid error:%s\n", strerror(errno ));
            return -1;
        }

        shm_id=shmget( key, 1024, IPC_CREAT |0660);
        if( shm_id == -1 )
        {
            fprintf(stderr, "shmget create error:%s\n", strerror(errno) );
            return -1;
        }
    }

    char* pMap = (char *)shmat(shm_id, NULL, 0);

    if( (int)pMap == -1)
    {
        fprintf(stderr, "shmat create error:%s\n", strerror(errno) );
        shmctl(shm_id, IPC_RMID, NULL);
        return -1;
    }

    strcpy( pMap, "Bujiwu Swallow");

    getchar();

    shmdt(pMap);
    shmctl(shm_id, IPC_RMID, NULL);

    return 0;
}

#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>

using namespace std;

int main(int argc, char* argv[])
{
    key_t key = ftok("/etc/passwd", 'a');
    if( -1 == key )
    {
        fprintf(stderr, "Creat Key Error:%s\n", strerror(errno));
        return -1;
    }

    /*
     if your IPC are used by processes related bya fork()
    (parent-children-grandchildren) use IPC_PRIVATE as the key
    */
    int shm_id=shmget( key, 1024, IPC_CREAT|0660);

    if( shm_id == -1 )
    {
        if ( shmctl(shm_id, IPC_RMID, NULL) == -1 )
        {
            fprintf(stderr, "shmctl remove shmid error:%s\n", strerror(errno ));
            return -1;
        }

        shm_id=shmget( key, 1024, IPC_CREAT |0660);
        if( shm_id == -1 )
        {
            fprintf(stderr, "shmget create error:%s\n", strerror(errno) );
            return -1;
        }
    }
    char* pMap = (char *)shmat(shm_id, NULL, 0);

    if( (int)pMap == -1)
    {
        fprintf(stderr, "shmat create error:%s\n", strerror(errno) );
        shmctl(shm_id, IPC_RMID, NULL);
        return -1;
    }

    printf("Shared  memory::%s\n", pMap);

    shmdt(pMap);
    shmctl(shm_id, IPC_RMID, NULL);

    return 0;
}

http://www.cppblog.com/Files/bujiwu/ShareMemory.rar

bujiwu 2009-11-08 09:39 发表评论