linux应用编程实例

㈠ linux用户空间 - 多进程编程（三）

管道用于有学园关系的进程之间。

管道的pipe 系统调用实际上就是创建出来两个文件描述符。
当父进P1程创建出 fd[2] 时，子进程P2 会继承父进程的所有，所以也会得到pipe 的 2个 文件描述符。
所以毫无瓜葛的两个进程，一定不会访问到彼此的pipe。无法用管道进行通信。
管道一般是单工的。f[0]读，f[1]写

管道也可以适用于 兄弟进程（只要有血缘即可）。由于管道是单工的，当两个进程之间需要双向通信，则需要两跟管道。

执行

ctrl-c(2号信号) + SIGUSR1 信号 绑了一个新函数。则 ctrl-c 无效。
查看进程的信号

号信号被捕获。

将2号信号忽略掉

9号信号 kill 和19号信号 stop 不能乱搞，只能用缺省。
其它信号甚至段信号也都可以捕获。

改变程序的执行现场，修改PC指针，有些像goto，只不过返回非0值

运行结果
making segment fault
after segment fault

程序不会死。
如果不忽略 page fault
则会产生 core mp.

不停的给data 赋值，同时每隔1s会有信号进来，打印 data的值。

理论上打印出来的结果同时为0，同时为1
但并非如此，是 0，1，交替随机的。

signal 异步的，随时都可以进来，所以打印出来的结果，并不是我想要的。

信号对于应用程序来说，很像中断对于内核，都是访问临界区数据

信号被屏蔽，延后执行。
写多线程的程序时，不要以为只有线程之间有竞争，其实信号也会有竞争

system v 的IPC 年代有些久远。

有血缘关系的进程 key_t 都是相同的。

Key 是私有key IPV PRIVATE

可能用消息队列，可能用共享内存，可能用信号量进行通讯。
利用 _pathname 路径，约定好一条路径。和tcp/ip地址很像，来生成一个key_t key, 用msg_get shm_get 得到共享内存or 信号量。
int id 可以理解为文件描述符 fd。
其中Sys V 的共享内存 最为常用。

一定要检查路径，如果仅仅有2个进程，你没有创建路径，两者都是 -1（相当于大家约定好了），那当然能通信拉。但更多的进程出现，则会有问题。

一定要检查返回值

依然依靠key，但是api 实在是太挫了。P&V 操作都是 semop. (posix 的 ipc跟为简洁)

POSIX 共享内存当然也需要一个名字，但并不是路径。
无论读进程还是写进程，都需要传入相同的名字。
如果是unbuntu 会在以下路径生成文件

其实 2和3 是1 的符号链接。 只要保证是一个就能互相通信

关键点，mmap 内存的属性修改为 private 后，产生写时，虚拟地址一样，但是物理地址已经不同了

当然 如果子进程修改了程序背景，执行了 exec，那么完全不一样了，直接修改了内存逻辑。

㈡ linux 中TCP套接字编程实例 显示Bind() error:address already in use 怎么办 用netstat -nat 查看后结果

你所使用的套接字已被占用，在Bind()之前你是否申请了套接字，或者申请之后已经被占用，Bind所使用的套接字来源很重要，可以查查。再有就是linux里面你的程序如果非法退出或者没有使用close释放套接字，在程序结束以后系统会延时自动释放套接字资源，但是要等几分钟，之后你就可以重新使用了。

㈢ 《Linux命令编辑器Shell编程实例大全》pdf下载在线阅读全文，求百度网盘云资源

《Linux命令编辑器Shell编程实例大全》网络网盘pdf最新全集下载:
链接：https://pan..com/s/1KuGwNJWqX0jvV3RXtMVh4A

㈣ 在LINUX下键盘编程 编写键盘应用程序 能够获取键盘按键

提供一个输入按键应用程序实例，你参考一下。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <linux/input.h>
int main(void)
{
int buttons_fd;
int key_value,i=0,count;
struct input_event ev_key;
buttons_fd = open("/dev/input/event0", O_RDWR);
if (buttons_fd < 0) {
perror("open device buttons");
exit(1);
}
for (;;) {
count = read(buttons_fd,&ev_key,sizeof(struct input_event));
for(i=0; i<(int)count/sizeof(struct input_event); i++)
if(EV_KEY==ev_key.type)
printf("type:%d,code:%d,value:%d\n", ev_key.type,ev_key.code-1,ev_key.value);
if(EV_SYN==ev_key.type)
printf("syn event\n\n");
}
close(buttons_fd);
return 0;
}

㈤ Linux Shell 教程——想玩转linux就请一直看下去

Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁。Shell 既是一种命令语言，又是一种程序设计语言。

Shell 是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问操作系统内核的服务。

Ken Thompson 的 sh 是第一种 Unix Shell，Windows Explorer 是一个典型的图形界面 Shell。

Shell 在线工具

Shell 脚本（shell script），是一种为 shell 编写的脚本程序。

业界所说的 shell 通常都是指 shell 脚本，但读者朋友要知道，shell 和 shell script 是两个不同的概念。

由于习惯的原因，简洁起见，本文出现的 "shell编程" 都是指 shell 脚本编程，不是指开发 shell 自身。

Shell 编程跟 JavaScript、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Linux 的 Shell 种类众多，常见的有：

在一般情况下，人们并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 #!/bin/sh ，它同样也可以改为 #!/bin/bash 。

#! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序。

打开文本编辑器(可以使用 vi/vim 命令来创建文件)，新建一个文件 test.sh，扩展名为 sh（sh代表shell），扩展名并不影响脚本执行，见名知意就好，如果你用 php 写 shell 脚本，扩展名就用 php 好了。

输入一些代码，第一行一般是这样：

#!/bin/bash
echo "Hello World !"

运行实例 »

#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。

echo 命令用于向窗口输出文本。

1、作为可执行程序

将上面的代码保存为 test.sh，并 cd 到相应目录：

注意，一定要写成 ./test.sh ，而不是 test.sh ，运行其它二进制的程序也一样，直接写 test.sh，linux 系统会去 PATH 里寻找有没有叫 test.sh 的，而只有 /bin, /sbin, /usr/bin，/usr/sbin 等在 PATH 里，你的当前目录通常不在 PATH 里，所以写成 test.sh 是会找不到命令的，要用 ./test.sh 告诉系统说，就在当前目录找。

2、作为解释器参数

这种运行方式是，直接运行解释器，其参数就是 shell 脚本的文件名，如：

这种方式运行的脚本，不需要在第一行指定解释器信息，写了也没用。

㈥ Linux下如何实现shell多线程编程以提高应用程序的响应

Linux中多线程编程拥有提高应用程序的响应、使多cpu系统更加有效等优点，下面小编将通过Linux下shell多线程编程的例子给大家讲解下多线程编程的过程，一起来了解下吧。

#！/bin/bash

#———————————————————————————–

# 此例子说明了一种用wait、read命令模拟多线程的一种技巧

# 此技巧往往用于多主机检查，比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况

# 还说明了多线程的控制

#———————————————————————————–

function a_sub

{

# 此处定义一个函数，作为一个线程（子进程）

sleep 3 # 线程的作用是sleep 3s

}

tmp_fifofile=“/tmp/$.fifo” mkfifo $tmp_fifofile # 新建一个fifo类型的文件

exec 6《》$tmp_fifofile # 将fd6指向fifo类型

rm $tmp_fifofile thread=15 # 此处定义线程数

for

（（i=0;i《$thread;i++））;do echo

done 》&6 # 事实上就是在fd6中放置了$thread个回车符

for

（（i=0;i《50;i++））;do # 50次循环，可以理解为50个主机，或其他

read -u6 # 一个read -u6命令执行一次，就从fd6中减去一个回车符，然后向下执行，

# fd6中没有回车符的时候，就停在这了，从而实现了线程数量控制

{ # 此处子进程开始执行，被放到后台

a_sub &&

{ # 此处可以用来判断子进程的逻辑

echo “a_sub is finished”

}

||

{ echo “sub error”

}

echo 》&6 # 当进程结束以后，再向fd6中加上一个回车符，即补上了read -u6减去的那个

}

& done wait # 等待所有的后台子进程结束

exec 6》&- # 关闭df6 exit 0

说明：

此程序中的命令

mkfifo tmpfile

和linux中的命令

mknod tmpfile p

效？果相同。区别是mkfifo为POSIX标准，因此推荐使用它。该命令创建了一个先入先出的管道文件，并为其分配文件标志符6。管道文件是进程之间通信的一种方式，注意这一句很重要

exec 6《》$tmp_fifofile # 将fd6指向fifo类型

如果没有这句，在向文件$tmp_fifofile或者&6写入数据时，程序会被阻塞，直到有read读出了管道文件中的数据为止。而执行了上面这一句后就可以在程序运行期间不断向fifo类型的文件写入数据而不会阻塞，并且数据会被保存下来以供read程序读出。

通过运行命令：

time 。/multithread.sh 》/dev/null

最终运算时间： 50/15 = 3组（每组15）+1组（5个《15 组成一个组）= 4组，每组花费时间：3秒，

则 3 * 4 = 12 秒。

传统非多线程的代码 运算时间： 50 * 3 = 150 秒。

上面就是Linux下shell多线程编程的实例介绍了，使用多线程编程还能够改善程序结构，有兴趣的朋友不妨试试看吧。

㈦ 如何编写Linux 驱动程序

如何编写Linux设备驱动程序
回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。
Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。
以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料。
一、Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放。
2、把数据从内核传送到硬件和从硬件读取数据。
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。
4、检测和处理设备出现的错误。
在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。
已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。
最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。
读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。
如何编写Linux操作系统下的设备驱动程序

二、实例剖析
我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含<linux/config.h>，一般来讲最好使用。
由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}

这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
下面就开始写子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}

这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考Robert着的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}

这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}

在用insmod命令将编译好的模块调入内存时，init_mole 函数被调用。在这里，init_mole只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。
如果登记成功，返回设备的主设备号，不成功，返回一个负值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸载模块时，cleanup_mole函数被调用，它释放字符设备test在系统字符设备表中占有的表项。
一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。
下面编译 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename。
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod –f test.o
如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :
$ rmmod test
下一步要创建设备文件。
mknod /dev/test c major minor
c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以获得主设备号，可以把上面的命令行加入你的shell script中去。
minor是从设备号，设置成0就可以了。
我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}

编译运行，看看是不是打印出全1 ？
以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，DMA，I/O port等问题。这些才是真正的难点。请看下节，实际情况的处理。
如何编写Linux操作系统下的设备驱动程序
三、设备驱动程序中的一些具体问题
1。 I/O Port。
和硬件打交道离不开I/O Port，老的ISA设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。
有两个重要的kernel函数可以保证驱动程序做到这一点。
1）check_region(int io_port， int off_set)
这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。
参数1：I/O端口的基地址，
参数2：I/O端口占用的范围。
返回值：0 没有占用， 非0，已经被占用。
2）request_region(int io_port， int off_set，char *devname)
如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。
参数1：io端口的基地址。
参数2：io端口占用的范围。
参数3：使用这段io地址的设备名。
在对I/O口登记后，就可以放心地用inb()， outb()之类的函来访问了。
在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。

2。内存操作
在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。 请注意，kmalloc等函数返回的是物理地址！
注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。
内存映射的I/O口，寄存器或者是硬件设备的RAM(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。
另外，很多硬件需要一块比较大的连续内存用作DMA传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。
这可以通过牺牲一些系统内存的方法来解决。

3。中断处理
同处理I/O端口一样，要使用一个中断，必须先向系统登记。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申请的中断。
handle：中断处理函数指针。
flags：SA_INTERRUPT 请求一个快速中断，0 正常中断。
device：设备名。

如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。
4。一些常见的问题。
对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的办法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。
写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！

㈧ Linux多线程编程

程序代码test.c共两个线程，一个主线程，一个读缓存区的线程：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char globe_buffer[100];

void *read_buffer_thread(void *arg); //这里先声明一下读缓存的线程，具体实现写在后面了

int main()
{
int res,i;
pthread_t read_thread;
for(i=0;i<20;i++)
globe_buffer[i]=i;
printf("\nTest thread : write buffer finish\n");
sleep(3);\\这里的3秒是多余，可以不要。
res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL);
if (res != 0)
{
printf("Read Thread creat Error!");
exit(0);
}
sleep(1);
printf("waiting for read thread to finish...\n");

res = pthread_join(read_thread, NULL);
if (res != 0)
{
printf("read thread join failed!\n");
exit(0);
}
printf("read thread test OK, have fun!! exit ByeBye\n");
return 0;
}
void *read_buffer_thread(void *arg)
{
int i,x;
printf("Read buffer thread read data : \n");
for(i=0;i<20;i++)
{
x=globe_buffer[i];
printf("%d ",x);
globe_buffer[i]=0;//清空
}
printf("\nread over\n");
}
---------------------------------------------------------------------------------
以上程序编译：
gcc -D_REENTRANT test.c -o test.o –lpthread
运行这个程序：
$ ./test.o：

㈨ 《LinuxShell命令行及脚本编程实例详解》epub下载在线阅读，求百度网盘云资源

《Linux Shell命令行及脚本编程实例详解》（刘艳涛）电子书网盘下载免费在线阅读

链接：https://pan..com/s/1LzVOHvdKkPLVE9wfNoJC2A

书名：Linux Shell命令行及脚本编程实例详解

作者：刘艳涛

出版社：清华大学出版社

出版年份：2015-1

页数：408

内容简介：

本书理论结合实践，全面、系统地介绍了Linux Shell（Bash）脚本编程的语法、命令、技巧等内容。本书偏重于实践教学，在讲解理论知识时，通过一些典型实例让读者了解理论知识在实际环境中的应用，并对易混淆和较难理解的知识点做了重点分析，以加深读者对知识的理解。另外，作者专门为本书录制了高清配套教学视频，以帮助读者高效学习，同时也提供了本书实例源程序以方便读者学习。

本书共15章，分为两篇。主要内容包括：Linux及Linux Shell简介、初识Linux Shell、常用Shell（Bash）命令、Shell命令进阶、Shell编程基础、Shell的条件执行、Bash循环、Shell函数、正则表达式、脚本输入处理、Shell重定向、管道和过滤器、捕获、sed和awk，以及其他Linux Shell种类介绍。

本书使用了大量的实例详细地介绍了Bash的语法及各种技巧，并以循序渐进的方式讲解了Linux Shell（Bash）的各种特性，让读者能够迅速上手，并能学以致用。对于初次接触Linux Shell的读者，本书是一本很好的自学教材；对于接触过Linux Shell的读者，本书可以作为进阶读物或随时查阅的技术手册；另外，本书也可以作为高等学校相关专业的教材和各类培训学校的教材。

作者简介：

刘艳涛，就职于一家全球500强的通信公司，从事公司无线产品研发中心的Linux／Unix操作系统的管理和技术支持。拥有近6年的Linux系统管理与运维经验。在使用Shell等脚本实现自动化管理方面有丰富的经验。擅长配置Nagios与Ganglia集成的自动化监控和故障报警平台。在结合研发环境对Linux系统性能调优方面有深入的研究。

㈩ LINUX的应用程序控制文件，如.conf是什么语言编写的下附举例.

这尘袭团种语言是类C语言，往往有变成人员自己定义，不执行或不可执行，只是由某个软件检查并根据配置文禅高件派橘做相应的动作。