C++博客-Jiwu Bu-随笔分类-Linux

[转载]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 发表评论

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 发表评论

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 发表评论

进程间通讯--System V 消息队列

bujiwu — Sat, 07 Nov 2009 13:47:00 GMT

摘要: 参考文章:http://blog.chinaunix.net/u1/53810/showart_425856.html1．创建消息队列int msgget(key_t key, int msgflg);通常是msgflg =IPC_CREAT| IPC_EXCL|0666通过key_t ftok(const char *pathname, int proj_id);创建key_t2．队列读写ssi... 阅读全文

bujiwu 2009-11-07 21:47 发表评论

转载:什么是Core Dump

bujiwu — Thu, 05 Nov 2009 05:12:00 GMT

转载地址: http://blog.chinaunix.net/u/16292/showart_1844400.html

1、什么是Core Dump?
Core的意思是内存, Dump的意思是扔出来, 堆出来.
开发和使用Unix程序时, 有时程序莫名其妙的down了, 却没有任何的提示(有时候会提示core dumped). 这时候可以查看一下有没有形如core.进程号的文件生成, 这个文件便是操作系统把程序down掉时的内存内容扔出来生成的, 它可以做为调试程序的参考.
core dump又叫核心转储, 当程序运行过程中发生异常, 程序异常退出时, 由操作系统把程序当前的内存状况存储在一个core文件中, 叫core dump.

2、如何使用core文件?
gdb -c core文件路径 [应用程序的路径]
进去后输入where回车, 就可以显示程序在哪一行当掉的, 在哪个函数中.

3、为什么没有core文件生成呢?
有时候程序down了, 但是core文件却没有生成. core文件的生成跟你当前系统的环境设置有关系, 可以用下面的语句设置一下, 然后再运行程序便成生成core文件.
ulimit -c unlimited
core文件生成的位置一般于运行程序的路径相同, 文件名一般为core.进程号

4、用gdb查看core文件:
下面我们可以在发生运行时信号引起的错误时发生core dump了.
发生core dump之后, 用gdb进行查看core文件的内容, 以定位文件中引发core dump的行.
gdb [exec file] [core file]
如:
gdb ./test test.core
在进入gdb后, 用bt命令查看backtrace以检查发生程序运行到哪里, 来定位core dump的文件->行.

bujiwu 2009-11-05 13:12 发表评论

创建守护进程函数

bujiwu — Sun, 01 Nov 2009 14:15:00 GMT

void DaemonInit(void)
{
    pid_t pid;
    pid_t sid;

    // fork to leave parent
    pid = fork ();
    if (pid < 0)
    {
        std::cout << "failed to fork!" << std::endl;

        exit (EXIT_FAILURE);
    }
    else if (pid > 0)
    {
        //parent process go to exit
        exit (EXIT_SUCCESS);
    }

    //child process
    sid = setsid ();
    if (sid < 0)
    {
        std::cout << "Failed to set session id." << std::endl;

        exit (EXIT_FAILURE);
    }

    return;
}

bujiwu 2009-11-01 22:15 发表评论

Linux与Windows中map类erase方法的差异

bujiwu — Sun, 01 Nov 2009 02:40:00 GMT

1 #include <iostream>
2 #include <map>
3 #include <string>
4
5 using namespace  std;
6
7 int main(int argc, char* argv[])
8 {
9     map<string, int> MyMap;
10
11     MyMap["bujiwu"] = 26;
12     MyMap["swallow"] = 25;
13
14     std::cout <<"Before delete element:" << std::endl;
15     for( map<string, int>::iterator Itor = MyMap.begin();
16             Itor != MyMap.end(); Itor++ )
17     {
18         std::cout << Itor->first << "   " << Itor->second << std::endl;
19     }
20
21     for( map<string, int>::iterator Itor = MyMap.begin();
22             Itor != MyMap.end(); )
23     {
24         if ( Itor->first == "bujiwu" )
25         {
26             MyMap.erase(Itor++); //在windows下也可以Itor = MyMap.erase(Itor),但是在linux下不行。
27         }
28         else
29         {
30             Itor++;
31         }
32     }
33
34     std::cout <<"After delete element:" << std::endl;
35     for( map<string, int>::iterator Itor = MyMap.begin();
36             Itor != MyMap.end(); Itor++ )
37     {
38         std::cout << Itor->first << "   " << Itor->second << std::endl;
39     }
40
41     return 0;
42 }
43
44

通过测试在不管在linux还是Windows平台下,vector,list都有方法iterator erase( iterator _Where );
但是在Linux下map中没有方法iterator erase( iterator _Where ); 所以上述代码在Linux平台下第26行必须写成MyMap.erase(Itor++),而不能写能Itor = MyMap.erase(Itor). 在Windows下二种方法都可以。

bujiwu 2009-11-01 10:40 发表评论

fork学习笔记

bujiwu — Sun, 13 Sep 2009 12:25:00 GMT

1 #include <unistd.h>
2 #include <sys/types.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <errno.h>
6
7 int main(int argc ,char* argv[])
8 {
9     pid_t my_pid = getpid();
10     pid_t parent_pid = getppid();
11
12     printf("ProcessID =%ld  ParentID =%ld\n", my_pid, parent_pid);
13
14     pid_t child = fork();
15
16     printf("-------------------------------------\n");
17     printf("Fork Process ID = %ld \n", child );
18
19     switch( child )
20     {
21         case -1:
22                printf("Create my child process error by fork func, errno=%ld\n", strerror(errno) );
23                break;
24
25         case 0:
26               printf("This is child process! Process ID = %ld\n", getpid() );
27               break;
28
29         default:
30               printf("This is not child process! Process ID= %ld Child Process ID=%ld\n", getpid(), child);
31
32     }
33
34     printf("who am I? Process ID=%ld  Parent Process ID= %ld\n", getpid(), getppid());
35
36     return 0;
37 }
38

运行结果[swallow@localhost syspr]$ ./process
ProcessID =1182 ParentID =1090
-------------------------------------
Fork Process ID = 0
This is child process! Process ID = 1183
who am I? Process ID=1183 Parent Process ID= 1182
-------------------------------------
Fork Process ID = 1183
This is not child process! Process ID= 1182 Child Process ID=1183
who am I? Process ID=1182 Parent Process ID= 1090
[swallow@localhost syspr]$

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

bujiwu 2009-09-13 20:25 发表评论

Linux添加环境变量与GCC编译器添加INCLUDE与LIB环境变量

bujiwu — Sun, 25 Jan 2009 10:20:00 GMT

对所有用户有效在/etc/profile增加以下内容。只对当前用户有效在Home目录下的
.bashrc或.bash_profile里增加下面的内容：
(注意：等号前面不要加空格,否则可能出现 command not found)

#在PATH中找到可执行文件程序的路径。
export PATH =$PATH:$HOME/bin

#gcc找到头文件的路径
C_INCLUDE_PATH=/usr/include/libxml2:/MyLib
export C_INCLUDE_PATH

#g++找到头文件的路径
CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/usr/include/libxml2:/MyLib
export CPLUS_INCLUDE_PATH

#找到动态链接库的路径
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/MyLib
export LD_LIBRARY_PATH

#找到静态库的路径
LIBRARY_PATH=$LIBRARY_PATH:/MyLib
export LIBRARY_PATH

bujiwu 2009-01-25 18:20 发表评论

Linux线程学习笔记

bujiwu — Sun, 18 Jan 2009 06:00:00 GMT

1 #include <stdio.h>       /* standard I/O routines                 */
2 #include <pthread.h>     /* pthread functions and data structures */
3 #include <unistd.h>      /* head file for sleep function */
4
5 /* global mutex for our program. assignment initializes it */
6 pthread_mutex_t a_mutex = PTHREAD_MUTEX_INITIALIZER;
7
8 /* function to be executed by the new thread */
9 void* do_loop(void* data)
10 {
11     int me = *((int*)data);     /* thread identifying number */
12     int rc; /* contain mutex lock/unlock results */
13
14     /* lock the mutex, to assure exclusive */
15     rc = pthread_mutex_lock(&a_mutex);
16
17     for (int i=0; i< 4; i++)
18     {
19         printf("'%d' - Got '%d'\n", me, i);
20         sleep(1);
21     }
22
23     /* unlock mutex */
24     rc = pthread_mutex_unlock(&a_mutex);
25
26     /* terminate the thread */
27     pthread_exit(NULL);
28 }
29
30 /* like any CPlusPlus program, program's execution begins in main */
31 /*g++ -o Thread Thread.cpp -lpthread*/
32 int main(int argc, char* argv[])
33 {
34     int        thr_id;         /* thread ID for the newly created thread */
35     pthread_t  p_thread1;       /* thread's structure                     */
36     pthread_t  p_thread2;       /* thread's structure                     */
37     int        a = 1;  /* thread 1 identifying number            */
38     int        b = 2;  /* thread 2 identifying number            */
39
40     /* create a new thread that will execute 'do_loop()' */
41     thr_id = pthread_create(&p_thread1, NULL, do_loop, (void*)&a);
42
43     /* create a new thread */
44     thr_id = pthread_create(&p_thread2, NULL, do_loop, (void*)&b);
45
46     /*wait until sub thread exit*/
47     pthread_join(p_thread1, NULL);
48     pthread_join(p_thread2, NULL);
49
50     return 0;
51 }
52

编译： gcc -o pthread pthread.c -lpthread

Linux下线程与信号量例子

bujiwu 2009-01-18 14:00 发表评论

Gvim操作汇总

bujiwu — Sun, 04 Jan 2009 13:39:00 GMT

1、Vim中替换操作
   s/old/new/g   #替换当前行old为new
   6,7s/old/new/g #替换第六行到第七行中的old为new
   %s/old/new/g    #替换全部的old为new

2、查找字符串
   :/Count    #正向查找Count 按n显示下一次
   :%Count    #逆向查找Count
   在当前字符串上按*,正向查找当前字符串
   在当前字符串上按#,反向查找当前字符串

3、字符串联想
   Ctrl+p

4、重复上一行内容
   Ctrl+y

5、跳转
   gg 跳到文件首行
   G   跳到文件尾行
   123G 跳到第123行
   数字0 移到当前行末尾
   $     移到当前行首部
   光标在{、}、[、]等括号上按%跳到相应的括号上
6、新增一行
   o   在当前光标下一行新增一行
   O   在当前光标上一行新增一行

7、显示/隐藏行号
   set nu 显示行号
   set nonu 隐藏等号

8、在Gvim中执行外部shell命令
   :!外部命令，如:
   :!ls -l

9、删除/复制行
   dd 删除一行
   3dd 删除当前光标所在行的以下三行
   yy 复制一行
   3yy 复制三行
   p 粘贴

10、撤消与撤消的撤消
   u 撤消
   Ctrl+R 撤消的撤消

.vimrc模板
http://www.cppblog.com/Files/bujiwu/vimrc.rar

"============================================
syntax on
set nu

set autoindent
set cindent
set smartindent

set softtabstop=4
set tabstop=4
set shiftwidth=4
set expandtab
set smarttab

set nobackup

set cursorline

set tags="./tags,./../tags,./../../tags"
"=================================================

bujiwu 2009-01-04 21:39 发表评论

Linux下文件打包与解包

bujiwu — Sun, 04 Jan 2009 11:23:00 GMT

打包(.tar):
tar -cvf Pro.tar /home/lin/Pro   #将/home/lin/Pro文件夹下的所有文件打包成Pro.tar

打解包(.tar.gz)
tar -cvzf firefox-3.0.3.tar.gz firefox       #将firefox文件夹打包为firefox-3.0.3.tar.gz
tar -xvzf firefox-3.0.3.tar.gz

打解包(.tar.bz2)
tar -cvjf firefox-3.0.3.tar.bz2 firefox/    #将firefox文件夹打包为firefox-3.0.3.tar.bz2
tar -xvjf firefox-3.0.3.tar.bz2

参数说明：
c   创建新的档案文件。如果用户想备份一个目录或是一些文件，就要选择这个选项。
x   从档案文件中释放文件。
v   详细报告tar处理的文件信息。如无此选项，tar不报告文件信息。
z   用gzip来压缩/解压缩文件，加上该选项后可以将档案文件进行压缩，但还原时也一定要使用该选项进行解压缩。
f   使用档案文件或设备，这个选项通常是必选的。

bujiwu 2009-01-04 19:23 发表评论

Linux常用知识收集！

bujiwu — Sun, 04 Jan 2009 11:06:00 GMT

1、程序前台与后台切换
   ctrl+z 将进程切换到后台
   fg      调到前台

2、linux批量查找文件内容
   find ./ -name "*.cpp" | xargs grep '要查找的内容'
   如:find . -name "*.cpp" | xargs grep 'main'

   如果需要查找的内容包含特殊符号，比如$等等，grep要加参数
   find ./ -name "*.cpp" | xargs grep -F '要查找的内容'

3、删除特定类型的文件
   如:后缀是.log的文件
   find . -name "*.log" -exec rm {} \;
   或者: find . -name "*.log" | xargs rm

4、文件批量重命名
   将所有*.h后缀名的文件重命名为*.header
   rename .h .header *.h
   格式： rename 替换前的内容替换后的内容通配符

5、列出除什么之外的文件
   列出不包括swallow字符的文件： ls | grep -v swallow
   删除不包括swallow字符的文件： ls | grep -v swallow | xargs rm

6、将用户增加到sudo组
   root# vim /etc/sudoers
   在这里增加内容：
   ## Allow root to run any commands anywhere
   root    ALL=(ALL)   ALL
   bujiwu ALL=(ALL)   ALL

7、修改/etc/crontab文件增加系统定时运行程序功能

8、make时检测到时钟错误。您的创建可能是不完整.
   由于文件时钟与系统时钟不匹配。所以可以用touch更改文件时间来Update.
   find . -type f -exec touch {} \;

bujiwu 2009-01-04 19:06 发表评论

Linux下Makefile文件

bujiwu — Mon, 29 Dec 2008 14:40:00 GMT

生成动态库(*.so)Makefile文件#Lib information
CURDIR =$(shell pwd)
LIBNAME :=libmyso.so
OUTDIR :=$(CURDIR)
OUTFILE :=$(OUTDIR)/$(LIBNAME)

SRC =node.cpp
OBJS =$(SRC:.cpp=.o)

#Complier information
CC = g++
INCPATH :=
LIBPATH :=
LIBS :=
COMOPT := -O2

all:$(OBJS)
   $(CC) -fPIC -shared -o $(OUTFILE) $(OBJS)

%.o:%.cpp
    $(CC) -c $(COMOPT) $(INCPATH) -o $@ $<

clean:
    rm -rf $(CURDIR)/*.o

生成静态库(*.a)Makefile文件#lib information
CURDIR =$(shell pwd)
LIBNAME :=libmylib.a
OUTDIR :=$(CURDIR)
OUTFILE :=$(OUTDIR)/$(LIBNAME)

SRC = Display.cpp
OBJS =$(SRC:.cpp=.o)

#complier information
CC=g++
INCPATH :=
LIBPATH :=
LIBS :=
COMOPT := -O2

all:$(OBJS)
   ar -r $(OUTFILE) $(OBJS)

%.o:%.cpp
    $(CC) -c $(COMOPT) $(INCPATH) -o $@ $<

clean:
    rm -rf $(CURDIR)/*.o

比较通用的Makefile文件#CPP Files Directory
vpath %.cpp ./../
vpath %.cpp ./../Student

#Head Files Directory
vpath %.h ./../Student/

#Get Makefile Current Directory
CURDIR =$(shell pwd)

SRC =Main.cpp \
     Student.cpp

SRC_OBJ =$(SRC:.cpp=.o)
CCFLAGS =-O2 -g -DUT_4_16
CXX =g++
CPPFLAGS =

#Load Static Library
LIBDIR =-L $(CURDIR)/../StaticLib -lmylib $(CURDIR)/../DynamicLib/libmyso.so
#Load Library Head Files
INCDIR =-I $(CURDIR)/../StaticLib -I $(CURDIR)/../DynamicLib

.PHONY :all
all :edit run

.PHONY :edit
edit: $(SRC_OBJ)
$(SRC_OBJ):%.o :%.cpp
    $(CXX) $(INCDIR) -c $(CCFLAGS) $(CPPFLAGS) $< -o $@

.PHONY :run
run: $(SRC_OBJ)
    $(CXX) $(INCDIR) $(SRC_OBJ) $(LIBDIR) -o Main

.PHONY :clean
clean:
    rm $(SRC_OBJ)

最简单的Makefile文件#假设只有一个文件Main.cpp生成Makefile文件
Main:Main.o
g++ -o $@ $^
%.o:%.cpp %.h
g++ -c $@ $>

不需要手工添加各个文件的依赖关系，使用vpath自动搜索文件！
测试工程：
http://www.cppblog.com/Files/bujiwu/Linux.rar

bujiwu 2008-12-29 22:40 发表评论