2017-05-22 16:47:46 zhangxiao93 阅读数 1135
  • Linux C语言编程基础视频精讲

    本课程讲解Linux编程下C语言的基础编程知识,包括环境构建,Linux shell命令 ,Linux VI编辑器,Linux GCC编译器使用,C语言保留字,变量,表达式、语句、函数、程序的结构、数据结构与算法、链表与栈。

    17668 人正在学习 去看看 沈寒

进程环境变量

最早知道环境变量是装jdk时,需要对PATH进行操作,PATH也是全局环境变量.
Linux有一些环境变量可以在.bashrc中修改

#cabal 环境变量添加到PATH中
export PATH=$HOME/.cabal/bin:$PATH

进程也有环境变量,其实就是一些key-value
存储位置位于进程虚拟空间的高地址(栈之上).
通过下面一些函数来操作:

#include <stdlib.h>

char *getenv(const char * name);//返回环境变量的值
//成功返回0,失败返回非0
int setenv(const char *name, const char *value, int overwrite);
//overwrite 参数表示,如果name存在,rewrite非0,则替换,如果为0则不设置新的value
int putenv(char *string);

在CGI程序中,子进程通常需要设置环境变量:

if(pid==0)
{
    //...
    sprintf(meth_env, "REQUEST_METHOD=%s", req.methodString());
    sprintf(length_env, "CONTENT_LENGTH=%d", contentLengthValue);

    putenv(meth_env);
    putenv(length_env);
    //...
}

下面一段代码测试功能:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int main()
{
    const char * home="HOME";
    char *penv=getenv(home);
    char buf[128];
    sprintf(buf,"ZHANGXIAO=%s",penv);

    int ret=putenv(buf);
    assert(ret==0);

    penv=getenv("ZHANGXIAO");
    printf("%s\r\n",penv);


    ret = setenv("ZHANGXIAO","new value",0);
    assert(ret==0);

    penv=getenv("ZHANGXIAO");
    printf("%s\r\n",penv);

    ret = setenv("ZHANGXIAO","new value",1);
    assert(ret==0);

    penv=getenv("ZHANGXIAO");
    printf("%s\r\n",penv);

    return 0;
}

输出结果:

/home/zhangxiao
/home/zhangxiao
new velue
2013-01-24 11:10:24 bbliutao 阅读数 1201
  • Linux C语言编程基础视频精讲

    本课程讲解Linux编程下C语言的基础编程知识,包括环境构建,Linux shell命令 ,Linux VI编辑器,Linux GCC编译器使用,C语言保留字,变量,表达式、语句、函数、程序的结构、数据结构与算法、链表与栈。

    17668 人正在学习 去看看 沈寒

Linux 环境变量

一、环境变量的种类
按环境变量的生存周期来划分,Linux变量可分为两类:
1 永久的:需要修改配置文件,变量永久生效。
2 临时的:使用export命令声明即可,变量在关闭shell时失效。


二、查看环境变量
1、使用echo命令查看单个环境变量。例如:
echo $PATH
2、使用env查看所有环境变量。例如:
env --显示所有
env|grep HOME --搜索HOME环境变量
3、使用set查看所有本地定义的环境变量。
set --显示所有本地定义的
set|grep HELLO --搜索HELLO环境变量


三、增加环境变量
1、在/etc/profile文件中添加变量【对所有用户生效(永久的)】
用vi在文件/etc/profile文件中增加变量,该变量将会对Linux下所有用户有效,并且是“永久的”。
例如:编辑/etc/profile文件,添加CLASSPATH变量
# vi /etc/profile
添加如下内容:
export CLASSPATH=./JAVA_HOME/lib;$JAVA_HOME/jre/lib
注:修改文件后要想马上生效还要运行# source /etc/profile不然只能在下次重进此用户时生效。

2、在用户目录下的~/.bash_profile文件中增加变量【对单一用户生效(永久的)】
用VI在用户目录下的.bash_profile文件中增加变量,改变量仅会对当前用户有效,并且是“永久的”。
例如:编辑guok用户目录(/home/guok)下的.bash_profile
$ vi /home/guok/.bash.profile
添加如下内容:
export CLASSPATH=./JAVA_HOME/lib;$JAVA_HOME/jre/lib
注:修改文件后要想马上生效还要运行$ source /home/guok/.bash_profile不然只能在下次重进此用户时生效。

3、直接运行export命令定义变量【只对当前shell(BASH)有效(临时的)】
在shell的命令行下直接使用[export 变量名=变量值] 定义变量,该变量只在当前的shell(BASH)或其子shell(BASH)下是有效的,shell关闭了,变量也就失效了,再打开新shell时就没有这个变量,需要使用的话还需要重新定义。
例如:export HELLO="hello"
echo $HELLO


四、修改环境变量
1.修改环境变量的值
$ HELLO="New" #直接覆盖原来的值修改

2.设置环境变量为只读
使用readonly命令的话,变量就不可以被修改或删除了
例如:readonly HELLO
$ unset TEST --会发现此变量不能被删除
-bash: unset: TEST: cannot unset: readonly variable
$ TEST="New" --会发现此也变量不能被修改
-bash: TEST: readonly variable


五、删除一个环境变量
1.运行unset命令删除一个环境变量
unset $HELLO #删除HELLO环境变量

2.修改环境变量配置文件删除环境变量


2020-02-05 15:49:43 apollo_miracle 阅读数 1365
  • Linux C语言编程基础视频精讲

    本课程讲解Linux编程下C语言的基础编程知识,包括环境构建,Linux shell命令 ,Linux VI编辑器,Linux GCC编译器使用,C语言保留字,变量,表达式、语句、函数、程序的结构、数据结构与算法、链表与栈。

    17668 人正在学习 去看看 沈寒

1 linux添加环境变量分为两种情况:

  1. 临时变量,指当shell窗口关闭时变量失效,通过export命令添加
  2. 全局生效,修改/etc/profile文件,这样环境变量全局生效且不会因窗口的关闭而失效。

2 查看当前环境变量

echo $PATH

3 添加临时环境变量

export PATH=/usr/local/bin:$PATH
// PATH是变量名,这里是指添加到PATH这个环境变量中
// =后面是要添加的环境变量
// :$PATH是指把新添加的环境变量与原先的环境变量重新赋值给PATH这个变量,这里可以看出如果有多个环境变量时,应该使用:进行分隔,如
// export PATH=/usr/local/php/bin:/usr/local/mysql/bin:$PATH
// 当然$PATH是放在开头还是最后是没有影响的

这种方法添加的环境变量会立即生效,但是在窗口关闭后便会失效

4 添加全局环境变量

sudo vim /etc/profile
// 如果只修改当前用户的环境变量,则是`vim ~/.bashrc`
// 在文件的最后一行添加以下代码:
export PATH=$PATH:/opt/node-v12.14.1-linux-x64/bin
// 规则和用法如第二条所说

5 使配置文件生效

修改好配置文件后执行source /etc/profile使配置文件生效

source /etc/profile

问题

在/etc/profile下配置好环境变量后,每次关闭shell窗口后都需要再执行一次source /etc/profile才能生效,这个问题需要在~/.bashrc文件最后添加source /etc/profile,这样问题便得到解决

sudo vim ~/.bashrc

 

2014-11-20 15:03:08 lihfqq 阅读数 159
  • Linux C语言编程基础视频精讲

    本课程讲解Linux编程下C语言的基础编程知识,包括环境构建,Linux shell命令 ,Linux VI编辑器,Linux GCC编译器使用,C语言保留字,变量,表达式、语句、函数、程序的结构、数据结构与算法、链表与栈。

    17668 人正在学习 去看看 沈寒

Linux 的变量可分为两类:环境变量和本地变量

环境变量:或者称为全局变量,存在于所有的shell中,在你登陆系统的时候就已经有了相应的系统定义的环境变量了。Linux 的环境变量具有继承性,即子shell 会继承父shell 的环境变量。

本地变量:当前shell 中的变量,很显然本地变量中肯定包含环境变量。Linux 的本地变量的非环境变量不具备继承性。

 

Linux 中环境变量的文件

当你进入系统的时候,linux就会为你读入系统的环境变量,这些环境变量存放在环境变量的文件中。Linux 中有很多记载环境变量的文件,它们被系统按照一定的顺序读入。

1.    /etc/profile :

此文件为系统的环境变量,它为每个用户设置环境信息,当用户第一次登录时,该文件被执行。并从/etc/profile.d 目录的配置文件中搜集shell 的设置。

这个文件,是任何用户登陆操作系统以后都会读取的文件(如果用户的shell 是csh 、tcsh 、zsh ,则不会读取此文件),用于获取系统的环境变量,只在登陆的时候读取一次。

或者source /etc/profile

 

假设用户使用的是BASH ,那么

2.    /etc/bashrc :

在执行完/etc/profile 内容之后,接着就会执行此文件。另外,当每次一个新的bash shell 被打开时, 该文件被读取。

用户在登陆后执行完/etc/profile 中内容以后都会执行此文件,在新开一个bash 的时候也会执行此文件。

因此,如果你想让每个使用bash的用户每新开一个bash和每次登陆都执行某些操作,或者给他们定义一些新的环境变量,就可以在这个里面设置。

 

3.    ~/.bash_profile :

每个用户都可使用该文件输入专用于自己使用的shell信息。当用户登录时,该文件仅仅执行一次,默认情况下,它设置一些环境变量,执行用户的.bashrc 文件。

单个用户此文件的修改只会影响到他以后的每一次登陆系统。

因此,可以在这里设置单个用户的特殊的环境变量或者特殊的操作,那么它在每次登陆的时候都会去获取这些新的环境变量或者做某些特殊的操作,但是仅仅在登陆时。

 

4.    ~/.bashrc :

该文件包含专用于单个人的bash shell 的bash 信息,当登录时以及每次打开一个新的shell 时, 该该文件被读取。

单个用户此文件的修改会影响到他以后的每一次登陆系统和每一次新开一个bash 。

因此,可以在这里设置单个用户的特殊的环境变量或者特殊的操作,那么每次它新登陆系统或者新开一个bash ,都会去获取相应的特殊的环境变量和特殊操作。

 

~/.bash_logout :

当每次退出系统( 退出bash shell) 时, 执行该文件。

 

几个命令

env 和printenv

这两个变量用于打印所有的环境变量:

 

set

用于显示与设置当前本地变量。单独一个set就显示了当前环境的所有的变量,它肯定包括环境变量和一些非环境变量

 

unset

用于清除变量。不管这个变量是环境变量还是本地变量,它都可以清除。

-- 下面是清除本地变量

[admin@localhost Documents]$ set|grep mytt

mytt=xxx

[admin@localhost Documents]$ unset mytt

[admin@localhost Documents]$ set|grep mytt

-- 下面是清除环境变量

[admin@localhost Documents]$ env|grep MYTT

MYTT=xxx

[admin@localhost Documents]$ unset MYTT

[admin@localhost Documents]$ env|grep MYTT

 

export --自定义变量转成环境变量

用于把变量变成当前shell 和其子shell 的环境变量,存活期是当前的shell 及其子shell ,因此重新登陆以后,它所设定的环境变量就消失了。

如何将环境变量永久化?修改上面介绍的那几个环境变量的配置文件。

 

source

当直接执行一个脚本的时候,其实是在一个子shell 环境运行的,即开启了一个子shell 来执行这个脚本,脚本执行完后该子shell 自动退出。

有没有办法在当前shell 中执行一个脚本呢?使用source 命令就可以让脚本在当前shell 中执行。如:

[oracle@localhost NBU]$ cat test.sh    -- 查看脚本内容,显示变量内容

echo $myname

[oracle@localhost NBU]$ echo $myname -- 变量存在,内容是ilonng

ilonng

[oracle@localhost NBU]$ set |grep myname -- 变量是本地变量

myname=ilonng

[oracle@localhost NBU]$ env |grep myname -- 变量不是环境变量

[oracle@localhost NBU]$ sh test.sh -- 直接执行,新开子shell ,非环境变量的本地变量不具备继承性,在子shell 中不可见

-- 这里什么都没有输出

 

一、Shell变量分为本地变量和环境变量。 

1、本地变量 --在用户现有运行的脚本中使用 

1) 定义本地变量 格式: variable-name=value 

[root@localhost /root]# LOCALTEST="test" 

[root@localhost /root]# echo $LOCALTEST test 

2) 显示本地变量 格式: set 

例子:[root@localhost root]# set 

3) 清除本地变量 格式:unset variable-name 

例如:[root@localhost /root]# unset LOCALTEST 

此时再执行echo $LOCALTEST将看不到变量LOCALTEST的输出。 

 

2、环境变量 --在所有的子进程中使用 

1) 定义环境变量 格式: export variable-name=value (与本地变量的定义相比,多了一个export关键字) 

[root@localhost /root]# export DOMAIN="baidu" 

[root@ localhost shell]# vi testenv.sh 

#!/bin/bash 

echo $DOMAIN 

[root@localhost shell]# chmod +x testenv.sh 

[root@localhost shell]# ./testenv.sh 

baidu 

2) 显示环境变量 

格式: env (本地变量的显示使用set,环境变量的显示使用env) 

例子: [root@localhost test]# env 

3) 清除环境变量 格式:unset variable-name (用法与本地变量相同,都使用unset) 

例子: [root@localhost shell]# unset DOMAIN 

此时再执行./testenv.sh将看不到变量DOMAIN的输出。

2016-04-02 04:22:01 Sico2Sico 阅读数 329
  • Linux C语言编程基础视频精讲

    本课程讲解Linux编程下C语言的基础编程知识,包括环境构建,Linux shell命令 ,Linux VI编辑器,Linux GCC编译器使用,C语言保留字,变量,表达式、语句、函数、程序的结构、数据结构与算法、链表与栈。

    17668 人正在学习 去看看 沈寒

条件变量
1. 问题
某些情况下,某些线程有这个需求:
仅当满足某个特定条件时,才执行对应操作;
如果该条件不满足,就阻塞该线程,一直等到对应的条件满足才继续执行。

 解决方案:
 当条件满足时,使用信号量唤醒对应线程,
 当条件不满足时,使用信号量阻塞对应线程。
 并用互斥量(互斥锁)来保护对该条件的访问。

 Linux提供了一种更方便的机制来解决该类问题:条件变量
  1. 使用方法
    条件变量是一种特殊的“通知”,而不是指某个条件。
    当特定的条件满足时,就使用pthread_cond_signal发送该通知(即发送该条件)
    即通知等待该条件的线程,它所等待的条件已经满足了。

    当特定的条件还不满足时,就使用pthread_cond_wait来等待该通知(即等待该条件)

    条件变量和互斥量结合使用:
    (1) 等待”通知”的pthread_cond_wait和发送“通知”的pthread_cond_signal,
    这两个调用的内部实现,需要使用互斥量,用来保护该条件变量。

    (2) 用来判断条件是否满足的相关共享资源,也需要用该互斥量进行保护。
    
  2. 条件变量的使用接口
    1) 条件变量的表示
    类型:pthread_cond_t

    2) 条件标量的初始化
    编译时初始化:
    pthread_cond_t my_cond = PTHREAD_COND_INITIALIZER;
    运行时初始化:
    pthread_cond_t my_cond;
    pthread_cond_init(&my_cond, NULL);
    /* 参数2为NULL, 表示该条件变量使用默认属性 */

    3) 等待条件标量
    pthread_cond_wait
    原型:int pthread_cond_wait (pthread_cond_t *cond,
    pthread_mutex_t *mutex);
    参数:cond, 条件变量
    mutex, 该条件变量所使用的互斥量

     pthread_cond_timedwait
     原型: int  pthread_cond_timedwait(pthread_cond_t *cond,
                                                         pthread_mutex_t *mutex,
                                                         const struct timespec *abstime);
     功能:pthread_cond_wait的限时等待版本
     参数:abstime, 是一个绝对时间,即当前时间+超时时间
    
     注意:当因等待该条件变量而使该线程阻塞时,隐含了一个动作(对该互斥量进行解锁)
              当被唤醒时,即从该调用返回时,又隐含了一个动作(对该互斥量进行加锁)
    

    4) “发送”该条件变量
    即,通知(唤醒)等待该条件变量的线程。
    如果没有线程在等待该条件变量,则忽视该操作,无累积效应。(而多次执行V操作,将有“累积效应”)

     pthread_cond_signal
     原型: int  pthread_cond_signal(pthread_cond_t  *cond);
     功能: 如果有多个线程都在等待该条件变量,
              则,使用调度策略唤醒一个线程,其余线程继续等待。
    
     pthread_cond_broadcast
     原型:int  pthread_cond_broadcast(pthread_cond_t *cond);
     功能:唤醒等待该条件变量的所有线程。
    
  3. 实例
    生产者线程、消费者线程
    最多可以同时存放BUFF_SIZE个“产品”
    每个产品用一个整数表示。
    即使用int buff[BUFF_SIZE]存放所有产品。
    当buff放满时,不可以再生产。
    当buff为空时,不可以再消费

    分别调整生产者和消费者的速度,观察输出信息。
    main6.c

4.
创建两个线程5
线程1接收用户输入
接收完成后,由线程2对该字符串进行“加工”,即统计其长度,并打印输出。

同步要求:
接收到用户输入后,才能统计字符串长度。
用户统计完成后,才能继续接收用户输入。
main7.c


     ------------------------------
     lock
     if (判断是否需要等待)
        pthread_cond_wait(&cond, &lock)

     work     
     unlock
    -------------------------------
     pthread_cond_signal(&cond);
    _______________________________
   thread1:
        如果COUNT > 0 就执行work()
        否则,等待直到该条件满足


   pthread_mutex_lock(&lock);
   if (!(COUNT > 0)) {
        pthread_cond_wait(&conditon, &lock);
   } 
   pthread_mutex_unlock(&lock);
   work();


   线程2//
   COUNT++;

   pthread_mutex_lock(&lock);
   if(COUNT > 0) {
        pthread_cond_signal(&condition)
   } 

main6.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

#define BUFF_SIZE  3

int buff[BUFF_SIZE];
int pos_product;
int pos_consume;

// ∂®“ÂÃıº˛±‰¡øcond_product
pthread_cond_t cond_product;

// ∂®“ÂÃıº˛±‰¡øcond_consume
pthread_cond_t cond_consume;

// ∂®“Âœfl≥ê•≥‚À¯lock
pthread_mutex_t lock;

void init_work(void)
{
    // Ãıº˛±‰¡øµƒ≥ı ºªØ
    pthread_cond_init(&cond_product, NULL);
    pthread_cond_init(&cond_consume, NULL);

    // œfl≥ÃÀ¯µƒ≥ı ºªØ
    pthread_mutex_init(&lock, NULL);

    pos_product = 0;
    pos_consume = 0;    
}

void* handle_product(void *arg)
{
    int i;

    for(i=1; i<5; i++) {
        pthread_mutex_lock(&lock);
        if ((pos_product + 1) % BUFF_SIZE
              == pos_consume) {
            // ≤÷ø‚“—¬˙£¨”¶∏√◊Ë»˚ Ωµ»¥˝
            printf("Buff is full, wait...\n");
            pthread_cond_wait(&cond_product, &lock);       //µ±Ãıº˛±‰¡øŒ¥∑¢…˙∏ƒ±‰ ± £¨ Ω¯––µΩ’‚“ª≤Ωª·◊‘∂ØΩ‚À¯  £¨µ±Ãıº˛±‰¡ø¬˙◊„ «“ 
                                                    // À¯◊¥Ã¨Œ™Œ¥º”À¯◊¥Ã¨£¨◊‘∂غœÀ¯÷¥––œ¬“ª≤Ω
                                                  // »Ù À¯◊¥Ã¨Œ™ºœÀ¯◊¥Ã¨  £¨µ»¥˝∆‰À¯◊¥Ã¨Œ™Œ¥º”À¯  º”À¯∫Û÷¥–– œ¬“ª≤Ω 
        }
        buff[pos_product] = i;
        printf("Product a productor(%d)\n", i);

        pos_product++;
        if (pos_product >= BUFF_SIZE) {
            pos_product = 0;
        }

        //pos_product = (pos_product+1)%BUFF_SIZE;

        pthread_cond_signal(&cond_consume);
        pthread_mutex_unlock(&lock);

        printf("product sleep begin.\n");
        sleep(1);
        printf("product sleep end.\n");
    }
}

void* handle_consume(void *arg)
{
    int val;
    int i;
    for (i=1; i<5; i++) {
        pthread_mutex_lock(&lock);
        if (pos_consume == pos_product) {
            /* ◊Ë»˚ Ωµ»¥˝ */
            printf("Buff is empty, waiting...\n");
            pthread_cond_wait(&cond_consume, &lock);
        }   

        /* ¥”≤÷ø‚»°≥ˆ≤˙∆∑ */
        val = buff[pos_consume];
        printf("Consume a product. val = %d\n", val);

        /* –fi∏ƒø…œ˚∑—≤˙∆∑µƒŒª÷√ */
        pos_consume++;
        if (pos_consume >= BUFF_SIZE) {
            pos_consume = 0;
        }

        pthread_cond_signal(&cond_product);
        pthread_mutex_unlock(&lock);

        printf("consumer sleep...begin\n");
        sleep(3);
        printf("consumer sleep...end\n");
    }
}

int main(void)
{
    pthread_t th_product, th_consume;
    int ret;

    init_work();

    ret = pthread_create(&th_product, 0, handle_product, 0);
    if (ret != 0) {
        perror("create thread failed!\n");
        exit(1);
    }

    ret = pthread_create(&th_consume, 0, handle_consume, 0);
    if (ret != 0) {
        perror("create thread failed!\n");
        exit(1);
    }



    pthread_join(th_product, 0);
    pthread_join(th_consume, 0);

    return 0;
}

main7.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>


#define BUFF_SIZE  80
char buff[BUFF_SIZE];
pthread_cond_t  cond_input;
pthread_cond_t  cond_work;
pthread_mutex_t lock;

void *hanle_input(void *arg)
{
    int ret;
    int fd;

    fd = 0;
    while(1) {
        fd_set read_set;
        FD_ZERO(&read_set);
        FD_SET(fd, &read_set);

        ret = select(fd+1, &read_set, 0, 0, 0);
        if (ret == -1) {
            perror("select failed!\n");
            exit(1);
        } else {
            if (FD_ISSET(fd, &read_set)) {
                pthread_mutex_lock(&lock);
                if (buff[0] != '\0') {
                    pthread_cond_wait(&cond_input, &lock);
                }
                bzero(buff, sizeof(buff));
                ret = read(fd, buff, sizeof(buff));
                if (ret == -1) {
                    printf("read failed!\n");
                    exit(1);
                }

                pthread_cond_signal(&cond_work);
                pthread_mutex_unlock(&lock);
            }
        }
    }
}

void *hanle_work(void *arg)
{
    while(1) {
        pthread_mutex_lock(&lock);
        if (buff[0] == '\0') {
            pthread_cond_wait(&cond_work, &lock);
        }

        printf("You input %d characters\n", strlen(buff));
        buff[0] = '\0';

        pthread_cond_signal(&cond_input);
        pthread_mutex_unlock(&lock);
    }
}

static void init_work(void)
{
    pthread_cond_init(&cond_input, NULL);
    pthread_cond_init(&cond_work, NULL);
    pthread_mutex_init(&lock, NULL);
}

int main(void)
{
    int ret;
    pthread_t th_input;
    pthread_t th_work;

    init_work();

    ret = pthread_create(&th_input, 0, hanle_input, 0);
    if (ret != 0) {
        printf("create thread failed!\n");
    }

    ret = pthread_create(&th_work, 0, hanle_work, 0);
    if (ret != 0) {
        printf("create thread failed!\n");
    }

    pthread_join(th_input, 0);
    pthread_join(th_work, 0);

    return 0;
}

linux 环境变量

阅读数 576

linux 环境变量

博文 来自: pzw_0612

linux 配置环境变量

阅读数 1655

Linux 位置参数变量

阅读数 4178

Linux-----Linux设置环境变量

博文 来自: hekewangzi
没有更多推荐了,返回首页