我已经采取了一些这些想法，并做出了一个函数，应该执行迅速，如果大量的随机数是必需的。

如果你需要很多随机数，调用od的代价是很高的。相反，我只调用它一次，并存储来自/dev/urandom的1024个随机数。当调用rand时，返回最后一个随机数并按比例缩放。然后从缓存中删除它。当缓存为空时，再读取1024个随机数。

例子:

rand 10; echo $RET

返回RET中0到9(含9)之间的随机数。

declare -ia RANDCACHE
declare -i RET RAWRAND=$(( (1<<32)-1 ))

function rand(){  # pick a random number from 0 to N-1. Max N is 2^32
  local -i N=$1
  [[ ${#RANDCACHE[*]} -eq 0 ]] && { RANDCACHE=( $(od -An -tu4 -N1024 /dev/urandom) ); }  # refill cache
  RET=$(( (RANDCACHE[-1]*N+1)/RAWRAND ))  # pull last random number and scale
  unset RANDCACHE[${#RANDCACHE[*]}-1]     # pop read random number
};

# test by generating a lot of random numbers, then effectively place them in bins and count how many are in each bin.

declare -i c; declare -ia BIN

for (( c=0; c<100000; c++ )); do
  rand 10
  BIN[RET]+=1  # add to bin to check distribution
done

for (( c=0; c<10; c++ )); do
  printf "%d %d\n" $c ${BIN[c]} 
done

更新:这并不适用于所有n。如果使用小n，也会浪费随机比特。注意(在这种情况下)一个32位随机数有足够的熵容纳9个0到9之间的随机数(10*9=1,000,000,000 <= 2*32)，我们可以从每个32个随机源值中提取多个随机数。

#!/bin/bash

declare -ia RCACHE

declare -i RET             # return value
declare -i ENT=2           # keep track of unused entropy as 2^(entropy)
declare -i RND=RANDOM%ENT  # a store for unused entropy - start with 1 bit

declare -i BYTES=4         # size of unsigned random bytes returned by od
declare -i BITS=8*BYTES    # size of random data returned by od in bits
declare -i CACHE=16        # number of random numbers to cache
declare -i MAX=2**BITS     # quantum of entropy per cached random number
declare -i c

function rand(){  # pick a random number from 0 to 2^BITS-1
  [[ ${#RCACHE[*]} -eq 0 ]] && { RCACHE=( $(od -An -tu$BYTES -N$CACHE /dev/urandom) ); }  # refill cache - could use /dev/random if CACHE is small
  RET=${RCACHE[-1]}              # pull last random number and scale
  unset RCACHE[${#RCACHE[*]}-1]  # pop read random number
};

function randBetween(){
  local -i N=$1
  [[ ENT -lt N ]] && {  # not enough entropy to supply ln(N)/ln(2) bits
    rand; RND=RET       # get more random bits
    ENT=MAX             # reset entropy
  }
  RET=RND%N  # random number to return
  RND=RND/N  # remaining randomness
  ENT=ENT/N  # remaining entropy
};

declare -ia BIN

for (( c=0; c<100000; c++ )); do
  randBetween 10
  BIN[RET]+=1
done

for c in ${BIN[*]}; do
  echo $c
done

如果您使用的是linux系统，您可以从/dev/random或/dev/ urrandom中获取一个随机数。注意，如果没有足够的随机数可用，/dev/random将阻塞。如果你需要速度超过随机性，请使用/dev/ urrandom。

这些“文件”将由操作系统生成的随机数填充。如果你得到的是真随机数还是伪随机数，这取决于系统上/dev/random的实现。真正的随机数是在从鼠标、硬盘、网络等设备驱动程序收集噪声的帮助下生成的。

您可以使用dd从文件中获取随机数

也许我说得有点晚了，但是在Bash中使用jot生成一个范围内的随机数怎么样?

jot -r -p 3 1 0 1

这将生成一个随机的(-r)数字，具有3位小数点后精度(-p)。在本例中，您将得到0到1(1 0 1)之间的一个数字。您还可以打印顺序数据。根据手册，随机数的来源为:

当没有指定种子时，通过arc4random(3)获得随机数，通过 随机(3)当一个种子给出。

请参阅$RANDOM:

$RANDOM是一个内部Bash函数 (不是常量)返回 范围内的伪随机整数 0 - 32767。它不应该被用来 生成加密密钥。

使用随机的美元。它通常与简单的shell算法结合使用很有用。例如，要生成1到10(包括)之间的随机数:

$ echo $((1 + $RANDOM % 10))
3

实际的生成器在variables.c中，即函数brand()。旧版本是一个简单的线性生成器。bash 4.0版本使用了一个引用1985年论文的生成器，这可能意味着它是一个不错的伪随机数来源。我不会将它用于模拟(当然也不会用于加密)，但它可能足以用于基本的脚本任务。

如果你在做一些需要大量随机数的事情，你可以使用/dev/random或/dev/urandom(如果它们可用的话):

$ dd if=/dev/urandom count=4 bs=1 | od -t d

从/dev/random或/dev/urandom字符特殊文件读取是可行的方法。

这些设备在读取和设计时返回真正的随机数 帮助应用软件选择用于加密的安全密钥。这样的 随机数是从熵池中提取的 通过各种随机事件。{LDD3，乔纳森·科贝，亚历山德罗 Rubini和Greg Kroah-Hartman]

这两个文件是内核随机化的接口

void get_random_bytes_arch(void* buf, int nbytes)

它从硬件中抽取真正随机的字节，如果这样的功能是由硬件实现的(通常是)，或者它从熵池中抽取(包括事件之间的时间，如鼠标和键盘中断，以及注册在SA_SAMPLE_RANDOM中的其他中断)。

dd if=/dev/urandom count=4 bs=1 | od -t d

这是可行的，但将不需要的输出从dd写入到stdout。下面的命令给出了我需要的整数。我甚至可以得到指定的随机位数，因为我需要调整位掩码给算术展开:

me@mymachine:~/$ x=$(head -c 1 /dev/urandom > tmp && hexdump 
                         -d tmp | head -n 1 | cut -c13-15) && echo $(( 10#$x & 127 ))