进程 线程 锁 死锁

Linux和windows的换行符有什么不同。

​ windows下的文件换行是以 "\r\n"结束的，0D 0A

​ Linux这种类Unix系统是以"\n"结束的。 0A

1、常见linux指令

cd /	到根目录（所有的目录、文件、设备都在根目录下，是最上级的目录，系统运行时建立）
cd ~	到home目录（用来存放用户的主目录 ，只有建立新用户的时候产生）
ls	查看当前目录下的所有目录和文件
ls -a	查看当前目录下所有目录和文件，包括隐藏文件。
ls -l	查看所有文件和信息
mkdir a	建立文件夹
rm -f	删除文件（不询问）
rm aa	删除文件aa
rm -r aa	删除目录aa
mv aa bb	将目录aa改为 bb
mv /usr/aa /usr	剪切目录
cp /usr/aa /usr	j将aa复制到usr目录下
touch 文件名	创建文件
rm -rf 文件名	删除问价
：q	退出编辑
：wq	保存退出
tar -zvcf a.tar	解压
pwd	查看当前目录路径
chmod 777	修改文件权限
cat aa	查看文件内容

sudo apt-get update //更新软件列表

sudo apt-get upgrade //和软件列表相比，更新软件

sudo apt-get install 软件 //安装软件

2、linux内存占用情况

cat /proc/meminfo  检查内存使用状况
free  命令是一个用来获得内存使用概况的快速简单的方法

3、Linux 文件使用情况（df） 文件占磁盘大小（du）

df -h 查看系统中文件的使用情况  磁盘实际占用的数量
du -sh /app （目录）  统计目录（或文件）所占磁盘空间的大小。

4、Linux进程的五个段

BSS段：存放程序中未初始化的全局变量。       BSS段属于静态内存分配
数据段：通常用来存放已经初始化的全局变量。   数据段属于静态内存分配
代码段：存放程序执行代码的一块区域，        代码段
堆(heap): 存放进程运行过程中被动态分配的内存段，
栈(stack):用户存放临时创建的局部变量。（先进先出）它是由操作系统分配的，内存的申请与回收都由OS管理。

5、了解shell脚本么 ？写过什么？

作用：
        1、自动化运维，批量化重复操作，减轻管理员工作量。
        2、提高处理文本文件的速度，避免配置出错。
执行方法：
        1、chmod +X test.sh
        2、./test.sh
1、//打印本地信息        
#!/bin/bash
echo "Hello, $LOGNAME"
echo "Current date is `date`"
echo "User is `who i am`"
echo "Current directory `pwd`"
2、//2数相加
#!/bin/bash
if [ $# -ne 2 ]    //$# 添加到Shell的参数个数   -ne  检测两个数是否不相等
then
    echo "Usage - $0   x    y"     //$0 Shell本身的文件名   $1 第一个参数
    echo " Where x and y are two nos for which I will print sum"
    exit 1
fi
    echo "Sum of $1 and $2 is `expr $1 + $2`"    // expr命令可以实现数值运算、数值或字符串比较、字符串匹配、字符串提取、字符串长度计算等功能
3、//输出相反的字符   /除  % 余数  表达式和运算符之间要有空格 2 + 2
#/bin/bash
if [ $# -ne 1 ]
then 
    echo"Usage:$0 number"
    echo"  T will reverse of number"
    echo"For eg.$0 1234,I will print 4321"
    exit 1
fi
n=$1
rev=0
sd=0

while [ $n -gt 0 ]
do
      sd=`expr $n % 10`
      rev=`expr $rev \* 10  + $sd`
      n=`expr $n / 10`
done
      echo "reverse number is $rev"
4、//使用终端 计算，不适用shell脚本 
//（把前一个命令原本要输出到屏幕的数据当作是后一个命令的标准输入”）
echo 7.56 + 2.453 | bc   
5、//
    
写过什么：
         Shell程序从脚本中一行一行读取并执行这些命令。配置环境的时候的一些命令。

6、关于grep的用法

//grep 查找文件里符合条件的字符串。
grep --help   //查看grep用法
grep "abc" file1.txt file2.txt    //在file1.txt和file2.txt文件中查找有abc字符的行
grep "abc" file*  // 所有file开头的文件中查找有abc字符的行
grep -v "abc" file* //显示不包含匹配文本的所有行
grep -c "abc" file* //只输出匹配行的数量  

5、fork（）

1、fork()是创建进程函数。通过系统调用创建一个与原来进程几乎完全相同的进程
2、被调用一次，却能够返回两次
3、在父进程中，fork返回新创建子进程的进程ID
4、在子程中，fork返回0
5、如果出现错误，fork返回一个负值 

6、锁

多线程、进程并行访问共享资源时，一定要加锁保护 。

为什么加锁？
    多线程访问共享资源时，为防止产生脏数据和错误而采取的方式。多线程访问同一个数据库时，数据库是共享资源，所以对库操作要加锁。
    （因数据重复录入、共同处理等不规范操作而产生的混乱、无效数据）
1、互斥锁：
    避免多个线程同时操作一个共享资源。
    例如：线程池中的有多个空闲线程和一个任务队列。任何是一个线程都要使用互斥锁互斥访问任务队列，以避免多个线程同时访问任务队列以发生错乱。
2、条件锁：
    某个线程满足某个条件使用条件锁，可以改变程序处于阻塞状态。
    例如：在线程池中，没有任务时，任务队列为空，这时线程因为“任务队列为空”这个条件阻塞，一旦有任务进来，就会有一个信号量唤醒一个线程处理这个任务。
3、自旋锁：（自旋锁适合于短时间的的轻量级的加锁机制）
    一个线程想要获要获得一个被使用的自旋锁，会一直请求这个锁，不去干其他事情，直到获得这个锁。
    当发生阻塞时，互斥锁可以让CPU去处理其他的任务；而自旋锁让CPU一直不断循环请求获取这个锁。
4、读写锁：
    计算机中的某些数据被多个进程共享，对数据库操作有两种，一种是读操作，一种是写操作。可以允许多个读操作，只允许一个写操作。
5、递归锁：
    保护共享数据免受多个线程同时访问。

7、死锁

1、多个进程在运行过程中因争夺资源而造成的一种僵局
2、当一个进程申请资源时，如果这时没有可用资源，那么这个进程进入等待状态。如果所申请的资源被其他等待进程占有，那么该等待进程有可能再也无法改变状态。这种情况称为死锁。
    、、、、、、、、、、、
 产生原因：
    1、竞争资源
    2、进程间推进顺序非法
  产生必要条件：
    1、互斥条件   在一段时间内某资源仅为一进程所占用。
    2、请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
    3、不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
    4、环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。
  解决方法：
    1、通过协议来预防或避免死锁，确保系统不会进入死锁状态。
    2、允许系统进入死锁状态，然后检测它，并加以恢复。
    3、可以忽视这个问题，认为死锁不可能在系统内发生。

8、僵尸进程？避免产生僵尸进程？

//产生原因：
    1、子进程先结束而父进程后结束，即子进程结束后，父进程还在继续运行但是并未调用wait/waitpid，那子进程就会成为僵尸进程。
    2、在每个进程退出的时候，内核释放该进程所有的资源，保留的信息直到进程通过调用wait/waitpid时才会释放。如果没有调用wait/waitpid的话，那么保留的信息就不会释放。
//wait函数：
    1、阻塞并等待子进程退出 
    2、回收子进程残留资源 
    3、获取子进程结束状态(退出原因)
//避免方法：
    1、为了防止产生僵尸进程，在fork子进程之后我们都要wait它们
    2、当子进程退出的时候，内核都会给父进程一个SIGCHLD信号，建立一个捕获SIGCHLD信号的信号处理函数，在函数体中调用wait（或waitpid），就可以清理退出的子进程以达到防止僵尸进程的目的
  

9、进程 线程 协程

单进程单线程：一个人在一个桌子上吃菜。
单进程多线程：多个人在同一个桌子上一起吃菜。
多进程单线程：多个人每个人在自己的桌子上吃菜。

1、进程  
    进程是资源分配的最小单位。操作系统以进程为单位，分配系统资源（CPU、内存等）。
    系统运行一个程序就是一个进程从创建、运行、到消亡的过程。
2、线程（引入了线程，尽量减小程序在并发执行时所付出的时空开销，提高操作系统的并发性能。）
    线程是程序执行、拥有资源的最小单元。
    一个进程至少一个线程，如果一个进程有多个线程，那么这个应用程序可以成为多线程程序。
    
    线程有两种调度方式：
                      1、分时调度，每个线程轮流使用CPU的使用权，平均分配。
                      2、抢占式调度，优先级高的线程先使用CPU
 3、区别和联系
    1、线程作为调度和分配的基本单位，进程是拥有资源的基本单位。
    2、进程之间可以并发执行，同一个进程的多个线程也可以并发执行。
    3、进程是拥有资源的一个独立单位，线程不拥有系统资源。
    4、系统开销：进程更大。在创建和撤销进程的时候，系统都需要分配和回收资源。
    
    //联系
    1、一个线程只能属于一个进程、一个进程可以有多个线程，至少一个线程。
    2、资源分配给进程，同一个进程所有线程共享进程的所有资源。
    3、处理分给线程，真正在处理机上运行的是线程。
    4、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
4、协程
    1、协程，是一种比线程更加轻量级的存在，完全是由程序所控制（也就是在用户态执行）
    2、协程在子程序内部是可中断的，然后转而执行别的子程序，在适当的时候再返回来接着执行。
    3、不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，执行效率比多线程高很多。

进程间的通信方式：

管道(Pipe)：父子进程间的通信。
命名管道(FIFO)：用于无父子进程间的通信。
消息队列(Message Queue) ：克服信号的数据结构过于简单的问题，解决管道数据流无格式和缓冲区受限等问题。规定了每个进程的权限，避免仿冒信息的出现。
信号量(Semaphore) ：用于解决进程的同步和相关资源抢占。
共享内存（Shared Memory）：让多个进程访问一个内存空间，适合数据量极大和数据结构复杂的进程间通信，安全性不高。
套接字（Socket）：套接字是一种数据访问机制，不仅可用于进程通信，还可以用于网络通信。可以快速一直到其他平台上。

10、进程的控制

exit()：
    终止发出调用的进程。
    exit()函数和_exit()函数的最大区别就在于exit()函数在终止当前进程之前要检查该进程打开过哪些文件，把文件缓冲区中的内容写回文件。
    父进程可以由wait 函数取得子进程结束状态。
wait():
    系统调用wait()用于父进程和子进程的同步。
    1、父进程调用后，将进入睡眠状态，直到子进程结束或者父进程被其它进程终止。

1、在linux系统中，用户创建子进程的唯一方法就是使用fork()函数，系统通过exit()函数，结束进程。
2、父进程和子进程的同步通过wait()函数实现的。父进程调用wait（）函数的时候，父进程的执行被阻断，直到子进程进入僵死状态，然后，子进程的退出参数通过wait（）函数返回给父进程，wait（）常被用来判断子进程是否结束。

11、线程控制

//进程时操作系统中资源管理的最小单位，线程是程序执行的最小单位。
1、POSIX线程库：
     a、创建线程。通过函数pthread_create()实现，在创建成功的时候返回0，失败返回一个错误代码。
     b、结束线程。通过调用函数pthread_exit()实现，结束这个函数的线程，返回一个指向某个变量的指针。
 2、同步：
     a、用信号量进行同步。以信号量指针作为参数，归还信号量所占用的资源。
     b、用互斥量进行同步。在多线程的程序中同步访问的方法，互斥量的作用给某个对象加一把锁，每次允许一个线程去访问。
 3、多线程实现：
     a、定义一个线程数组，然后创建多个线程，并将线程的标识符保存在线程数组里。
     b、主线程依次等待每个线程的结束。
    
  4、多线程的实现方式：
     a、继承Thread类，重写run方法
     b、实现Runnable接口，重写run方法，创建Runable对象，通过Runable对象创建thread对象
     c、通过Callable和FutureTask创建线程
     d、通过线程池创建线程  

12、线程池主要参数

线程池：
    1、传统多线程方案，首先建立一个新的线程，由线程执行任务。任务执行完毕后，线程退出。  即时创建，即时销毁。   那么服务器一直处于建立线程和销毁线程的状态。
    2、线程池采用预创建的技术，在应用程序启动之后，将立即创建一定数量的线程(N1)，放入空闲队列中。
    3、当任务到来后，缓冲池选择一个空闲线程，把任务传入此线程中运行。
    4、在任务执行完毕后线程也不退出，继续保持在池中等待下一次的任务，当系统空闲时，大部分线程都一直处于暂停状态，线程池自动销毁一部分线程，回收系统资源。
    
适用场景：
    1、单位时间内处理任务频繁而且任务处理时间短（线程创建和撤销占任务时间比重就大）
    2、对实时性要求较高。如果接受到任务后在创建线程，可能满足不了实时要求，因此必须采用线程池进行预创建。

13、多进程和多线程

//多进程：
    计算机同时执行多个进程，一般是同时运行多个软件。
   1、避免阻塞
   2、避免CPU空转
   3、提升性能。子进程崩溃，不影响主进程和其他子进程。
    
//多线程：
   1、并行处理任务，更快获得计算结果。
   2、任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。
   产生原因：
    为了解决负载均衡问题,充分利用CPU资源。为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不互相干扰。
   优点：
    充分利用CPU和I/O的利用率，使运行效率提高。采用多线程的方式去同时完成几件事情而不互相干扰。
    
 //区别：
    1、多线程可以共享全局变量，多进程不能。
    2、多线程中，所有子线程的进程号一样，多进程中，不同的子进程进程号不一样。
    3、线程共享内存空间，进程的内存是独立的。
    4、同一个进程的线程使可以直接通信的。两个进程想要通信，必须找一个代理。
    5、创建线程很简单，创建进程需要对父进程进行克隆。
    6、一个线程可以控制和操作同一个进程的其他线程，进程只能操作子进程。

14、多进程并发和多线程并发

多进程并发：
    1、含义。将应用程序分为多个、独立的进程，运行在同一时刻，通过进程间的通信渠道传递消息（信号、套接字、管道）。
    2、操作系统在进程间提供附加保护操作和通信机制，比线程更加容易的编写安全并发代码。
    3、使用独立的进程实现并发，提高并行可用性和提高性能的低成本方法。
    缺点：
    1、需要系统提供内部资源管理进程，维持多个进程所需要的开销。
 多线程并发：
    1、每个线程独立运行，进程中的所有线程共享相同的地址空间。
    2、共享地址空间，以及缺少线程间的数据保护，使得多线程相关的开销远小于多进程。
    缺点：
    1、虽然线程间共享内存单元，但是难以管理。
    2、数据如果被多个线程访问，必须保证每个线程访问的数据是一样的。

15、生产者-消费者模型，如果队列里面本来就有东西，这个时候生产者还需要唤醒消费者吗？

多线程并发协作的模型。
模型的三大优点：解藕，异步，平衡速度差异
    
//基于这种消息通知机制，我们还能够平衡生产者和消费者之间的速度差异
1、等着，其实就是用 wait() 来实现的；
    wait() 方法是用来让当前线程等待，直到有别的线程调用 notify() 将它唤醒，
2、通知，就是 notify() 或者 notifyAll() 。
    notify() 方法只能通知一个线程，如果多个线程在等待，那就唤醒任意一个。
    notifyAll() 方法是可以唤醒所有等待线程，然后加入同步队列。

    
1、如果队列里的产品已经满了，生产者就不能继续生产；
2、如果队列里的产品从无到有，生产者就得通知一下消费者，告诉它可以来消费了；
3、如果队列里已经没有产品了，消费者也无法继续消费；
4、如果队列里的产品从满到不满，消费者也得去通知下生产者，说你可以来生产了。
 

16、设计模式

1、工厂模式
    创建对象时不向客户端暴露创建逻辑，通过一个共同的接口指向新创建的对象。一般在创建复杂对象时，考虑使用；在创建简单对象时，建议直接new完成一个实例对象的创建。